README.md (view raw)
1# Golang bindings for the Telegram Bot API
2
3[](https://pkg.go.dev/github.com/go-telegram-bot-api/telegram-bot-api/v5)
4[](https://github.com/go-telegram-bot-api/telegram-bot-api/actions/workflows/test.yml)
5
6All methods are fairly self-explanatory, and reading the [godoc](http://godoc.org/github.com/go-telegram-bot-api/telegram-bot-api) page should
7explain everything. If something isn't clear, open an issue or submit
8a pull request.
9
10The scope of this project is just to provide a wrapper around the API
11without any additional features. There are other projects for creating
12something with plugins and command handlers without having to design
13all that yourself.
14
15Join [the development group](https://telegram.me/go_telegram_bot_api) if
16you want to ask questions or discuss development.
17
18## Example
19
20First, ensure the library is installed and up to date by running
21`go get -u github.com/go-telegram-bot-api/telegram-bot-api/v5`.
22
23This is a very simple bot that just displays any gotten updates,
24then replies it to that chat.
25
26```go
27package main
28
29import (
30 "log"
31
32 tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
33)
34
35func main() {
36 bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
37 if err != nil {
38 log.Panic(err)
39 }
40
41 bot.Debug = true
42
43 log.Printf("Authorized on account %s", bot.Self.UserName)
44
45 u := tgbotapi.NewUpdate(0)
46 u.Timeout = 60
47
48 updates, err := bot.GetUpdatesChan(u)
49
50 for update := range updates {
51 if update.Message == nil { // ignore any non-Message Updates
52 continue
53 }
54
55 log.Printf("[%s] %s", update.Message.From.UserName, update.Message.Text)
56
57 msg := tgbotapi.NewMessage(update.Message.Chat.ID, update.Message.Text)
58 msg.ReplyToMessageID = update.Message.MessageID
59
60 bot.Send(msg)
61 }
62}
63```
64
65There are more examples on the [site](https://go-telegram-bot-api.dev/)
66with detailed information on how to do many kinds of things.
67It's a great place to get started on using keyboards, commands, or other
68kinds of reply markup.
69
70If you need to use webhooks (if you wish to run on Google App Engine),
71you may use a slightly different method.
72
73```go
74package main
75
76import (
77 "log"
78 "net/http"
79
80 "github.com/go-telegram-bot-api/telegram-bot-api"
81)
82
83func main() {
84 bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
85 if err != nil {
86 log.Fatal(err)
87 }
88
89 bot.Debug = true
90
91 log.Printf("Authorized on account %s", bot.Self.UserName)
92
93 _, err = bot.SetWebhook(tgbotapi.NewWebhookWithCert("https://www.google.com:8443/"+bot.Token, "cert.pem"))
94 if err != nil {
95 log.Fatal(err)
96 }
97 info, err := bot.GetWebhookInfo()
98 if err != nil {
99 log.Fatal(err)
100 }
101 if info.LastErrorDate != 0 {
102 log.Printf("Telegram callback failed: %s", info.LastErrorMessage)
103 }
104 updates := bot.ListenForWebhook("/" + bot.Token)
105 go http.ListenAndServeTLS("0.0.0.0:8443", "cert.pem", "key.pem", nil)
106
107 for update := range updates {
108 log.Printf("%+v\n", update)
109 }
110}
111```
112
113If you need to publish your bot on AWS Lambda(or something like it) and AWS API Gateway,
114you can use such example:
115
116In this code used AWS Lambda Go net/http server adapter [algnhsa](https://github.com/akrylysov/algnhsa)
117
118```go
119package main
120
121import (
122 "github.com/akrylysov/algnhsa"
123 "github.com/go-telegram-bot-api/telegram-bot-api"
124 "log"
125 "net/http"
126)
127
128func answer(w http.ResponseWriter, r *http.Request) {
129 bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
130 if err != nil {
131 log.Fatal(err)
132 }
133
134 bot.Debug = true
135 updates := bot.ListenForWebhookRespReqFormat(w, r)
136 for update := range updates {
137 if update.Message == nil {
138 continue
139 }
140 log.Printf("[%s] %s", update.Message.From.UserName, update.Message.Text)
141
142 msg := tgbotapi.NewMessage(update.Message.Chat.ID, update.Message.Text)
143 msg.ReplyToMessageID = update.Message.MessageID
144 _, err := bot.Send(msg)
145 if err != nil {
146 log.Printf("Error send message: %s | Error: %s", msg.Text, err.Error())
147 }
148 }
149}
150
151func setWebhook(_ http.ResponseWriter, _ *http.Request) {
152 bot, err := tgbotapi.NewBotAPI("MyAwesomeBotToken")
153 if err != nil {
154 log.Fatal(err)
155 }
156
157 bot.Debug = true
158
159 log.Printf("Authorized on account %s", bot.Self.UserName)
160
161 _, err = bot.SetWebhook(tgbotapi.NewWebhook("https://your_api_gateway_address.com/"+bot.Token))
162 if err != nil {
163 log.Fatal(err)
164 }
165 info, err := bot.GetWebhookInfo()
166 if err != nil {
167 log.Fatal(err)
168 }
169 if info.LastErrorDate != 0 {
170 log.Printf("Telegram callback failed: %s", info.LastErrorMessage)
171 }
172}
173
174func main() {
175 http.HandleFunc("/set_webhook", setWebhook)
176 http.HandleFunc("/MyAwesomeBotToken", answer)
177 algnhsa.ListenAndServe(http.DefaultServeMux, nil)
178}
179```
180
181If you need, you may generate a self-signed certificate, as this requires
182HTTPS / TLS. The above example tells Telegram that this is your
183certificate and that it should be trusted, even though it is not
184properly signed.
185
186 openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 3560 -subj "//O=Org\CN=Test" -nodes
187
188Now that [Let's Encrypt](https://letsencrypt.org) is available,
189you may wish to generate your free TLS certificate there.