https://github.com/raminsa/telegram-bot-api
Golang Telegram Bot API
https://github.com/raminsa/telegram-bot-api
golang telegram telegram-api telegram-bot telegram-bot-api
Last synced: 5 months ago
JSON representation
Golang Telegram Bot API
- Host: GitHub
- URL: https://github.com/raminsa/telegram-bot-api
- Owner: raminsa
- Created: 2022-07-17T12:15:27.000Z (almost 4 years ago)
- Default Branch: main
- Last Pushed: 2024-07-07T12:12:01.000Z (almost 2 years ago)
- Last Synced: 2024-07-07T13:34:16.812Z (almost 2 years ago)
- Topics: golang, telegram, telegram-api, telegram-bot, telegram-bot-api
- Language: Go
- Homepage: https://core.telegram.org/bots
- Size: 369 KB
- Stars: 3
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Security: SECURITY.md
Awesome Lists containing this project
README
# Telegram Bot API
The Telegram Bot API provides an HTTP API for creating Telegram Bots.
If you've got any questions about bots or would like to report an issue with your bot, kindly contact us at @BotSupport in Telegram.
Please note that only global Bot API issues that affect all bots are suitable for this repository.
To learn how to use it, please see our [examples](https://github.com/raminsa/telegram-bot-api/tree/main/examples).
Bot API 7.7 recent changes [July 7, 2024](https://core.telegram.org/bots/api#july-7-2024).
## Table of Contents
- [Installation](#installation)
- [Documentation](#documentation)
- [Example](#example)
- [Custom Client](#custom-client)
- [Debug](#debug)
## Installation
`go get github.com/raminsa/telegram-bot-api`.
## Documentation
See [Bots: An introduction for developers](https://core.telegram.org/bots) for a brief description of Telegram Bots and their features.
See the [Telegram Bot API documentation](https://core.telegram.org/bots/api) for a description of the Bot API interface and a complete list of available classes, methods and updates.
See the [Telegram Bot API server build instruction generator](https://tdlib.github.io/telegram-bot-api/build.html) for detailed instructions on how to build the Telegram Bot API server.
Subscribe to [@BotNews](https://t.me/botnews) to be the first to know about the latest updates and join the discussion in [@BotTalk](https://t.me/bottalk).
use get update method (simple):
```go
package main
import (
"fmt"
"log"
"github.com/raminsa/telegram-bot-api/telegram"
)
func main() {
tg, err := telegram.New("BotToken")
if err != nil {
log.Fatal(err)
}
getUpdates := tg.NewGetUpdates()
getUpdates.Offset = 1
getUpdates.Timeout = 60
getUpdates.Limit = 100
updates := tg.GetUpdatesChan(getUpdates)
for update := range updates {
fmt.Println(update.UpdateID, getUpdates.Offset)
if update.UpdateID >= getUpdates.Offset {
getUpdates.Offset = update.UpdateID + 1
}
if update.Message != nil {
fmt.Println(update.Message.Text)
}
}
}
```
use webhook method (http):
```go
package main
import (
"fmt"
"log"
"net/http"
"github.com/raminsa/telegram-bot-api/telegram"
)
func main() {
fmt.Println("start at port:", "BotPortNumber")
err := http.ListenAndServe("BotPortNumber", http.HandlerFunc(handleWebhook))
if err != nil {
log.Fatal(err)
}
}
func handleWebhook(w http.ResponseWriter, r *http.Request) {
update, err := telegram.HandleUpdate(r)
if err != nil {
err = telegram.HandleUpdateError(w, err)
if err != nil {
//handle err
}
return
}
if update.Message != nil {
fmt.Println(update.Message.Text)
}
}
```
use webhook method (https):
```go
package main
import (
"fmt"
"log"
"net/http"
"github.com/raminsa/telegram-bot-api/telegram"
)
func main() {
fmt.Println("start at port:", "BotPortNumber")
err := http.ListenAndServeTLS("BotPortNumber", "BotCertFile", "BotKeyFile", http.HandlerFunc(handleWebhook))
if err != nil {
log.Fatal(err)
}
}
func handleWebhook(w http.ResponseWriter, r *http.Request) {
update, err := telegram.HandleUpdate(r)
if err != nil {
err := telegram.HandleUpdateError(w, err)
if err != nil {
//handle err
}
return
}
if update.Message != nil {
fmt.Println(update.Message.Text)
}
}
```
to generate your cert file use this. See [self-signed](https://core.telegram.org/bots/self-signed) guide for details.:
openssl req -newkey rsa:2048 -sha256 -nodes -keyout -x509 -days 36500 -out -subj "/C=US/ST=New York/L=Brooklyn/O=Example Brooklyn Company/CN="
use a channel to handle all requests (Avoid ReadTimeoutExpired error), http.ListenAndServe() supports concurrency:
```go
package main
import (
"fmt"
"net/http"
"github.com/raminsa/telegram-bot-api/telegram"
"github.com/raminsa/telegram-bot-api/types"
)
func main() {
fmt.Println("start at port:", "BotPortNumber")
updates := listenForWebhook(100)
go http.ListenAndServeTLS("BotPortNumber", "BotCertFile", "BotKeyFile", nil)
for update := range updates {
if update.Message != nil {
fmt.Println(update.Message.Text)
}
}
}
func listenForWebhook(maxWebhookConnections int) types.UpdatesChannel {
ch := make(chan types.Update, maxWebhookConnections)
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
if update, err := telegram.HandleUpdate(r); err != nil {
return
} else {
ch <- *update
}
})
return ch
}
```
## Custom Client
use client with custom options:
```go
package main
import (
"fmt"
"log"
"github.com/raminsa/telegram-bot-api/telegram"
)
func main() {
client := telegram.Client()
client.BaseUrl = "baseUrl"
client.Proxy = "proxy"
client.ForceV4 = true
client.DisableSSLVerify = true
client.ForceAttemptHTTP2 = true
tg, err := telegram.NewWithCustomClient("BotToken", client)
if err != nil {
log.Fatal(err)
}
me, err := tg.GetMe()
if err != nil {
log.Fatal(err)
}
fmt.Println("botID:", me.ID, "botUsername:", me.UserName)
}
```
use debug option and write to local file:
```go
package main
import (
"fmt"
"log"
"github.com/raminsa/telegram-bot-api/telegram"
)
func main() {
tg, err := telegram.NewWithBaseUrl("BotToken", "baseUrl")
if err != nil {
log.Fatal(err)
}
//active debug mode
tg.Bot.Debug = true
me, err := tg.GetMe()
if err != nil {
log.Fatal(err)
}
fmt.Println("botID:", me.ID, "botUsername:", me.UserName)
//access debug log
//method 1: write to console
fmt.Println(tg.GetLoggerFile())
//method 2: write to file
err = tg.WriteLoggerFile("fileName")
if err != nil {
log.Fatal(err)
}
}
```