Telebot

To install the Telebot v4 framework, use the following Go command:

go get -u gopkg.in/telebot.v4

Telebot supports middleware as chained functions that have access to tele.Context. Middleware can be applied globally, to a specific group of handlers, or to a single handler.

To use built-in middleware, import gopkg.in/telebot.v4/middleware.

// Global-scoped middleware
b.Use(middleware.Logger())

// Group-scoped middleware
adminOnly := b.Group()
adminOnly.Use(middleware.Whitelist(adminIDs...))
adminOnly.Handle("/ban", onBan)

// Handler-scoped middleware
b.Handle(tele.OnText, onText, middleware.IgnoreVia())

To initialize a bot, create a tele.Settings object containing your Token and a Poller (such as tele.LongPoller). Use tele.NewBot(pref) to create the bot instance, define handlers using b.Handle, and call b.Start() to begin processing updates.

package main

import (
	"log"
	"os"
	"time"

	ele "gopkg.in/telebot.v4"
)

func main() {
	pref := tele.Settings{
		Token:  os.Getenv("TOKEN"),
		Poller: &tele.LongPoller{Timeout: 10 * time.Second},
	}

	b, err := tele.NewBot(pref)
	if err != nil {
		log.Fatal(err)
		return
	}

	b.Handle("/hello", func(c tele.Context) error {
		return c.Send("Hello!")
	})

	b.Start()
}

Use NewBot to create a new Telegram bot instance. You must provide a Settings struct containing at least the Token.

Key Settings fields:

• Token: The secret API key for your bot.
• Updates: Capacity of the updates channel (defaults to 100).
• Poller: The provider of updates (defaults to LongPoller).
• Synchronous: If true, prevents handlers from running in parallel.
• Verbose: If true, logs all upcoming requests (use for debugging).
• ParseMode: Default parse mode for all sent messages.
• OnError: Callback for handler errors.
• Offline: If true, creates a bot without network connection (useful for testing).

The Send() method is used to send messages or media. It accepts a Recipient and a Sendable.

To control message properties (like disabling web link previews or notifications), you can use:

• &tele.SendOptions{} for full control.
• &tele.ReplyMarkup{} for keyboards.
• Functional flags like tele.Silent or tele.NoPreview.

// Using full SendOptions
b.Send(user, "text", &tele.SendOptions{
	// ...
})

// Using ReplyMarkup shorthand
b.Send(user, "text", &tele.ReplyMarkup{
	// ...
})

// Using functional flags
b.Send(user, "text", tele.Silent, tele.NoPreview)

// Sending an Album
p := &tele.Photo{File: tele.FromDisk("chicken.jpg")}
v := &tele.Video{File: tele.FromURL("http://video.mp4")}
msgs, err := b.SendAlbum(user, tele.Album{p, v})

Telebot supports direct command routing (e.g., /start) and handles both /command and /command@botname syntax.

• Use c.Message().Payload to extract data from deep-links (e.g., /start <PAYLOAD>).
• Use c.Args() to get a slice of arguments split by spaces.

Telebot provides a transparent File API. You can upload files from disk or URL. When sending a file created via tele.FromDisk, Telebot automatically uploads it. Subsequent sends of the same file will use the FileID instead of re-uploading.

a := &tele.Audio{File: tele.FromDisk("file.ogg")}

// Uploads the file and sends it
b.Send(recipient, a)

// Subsequent sends use the cached FileID
b.Send(otherRecipient, a)

The tele.Context type wraps the Telegram update and provides helpers to access message data. You can use it to get the sender, text, or specific message types (like Photo) and use shorthand methods like c.Send() to respond directly.

b.Handle(tele.OnText, func(c tele.Context) error {
	var (
		user = c.Sender()
		text = c.Text()
	)

	// Use context shorthand to respond
	return c.Send(text)
})

b.Handle(tele.OnPhoto, func(c tele.Context) error {
	photo := c.Message().Photo
	_ = photo
	return nil
})