# How to Configure Telego HTTP Client: FastHTTP vs net/http

> Configure Telego HTTP client using FastHTTP or net/http for your Telegram bot with telego.WithFastHTTPClient() or telego.WithHTTPClient(). Optimize API requests now.

- Repository: [Artem Yadelskyi/telego](https://github.com/mymmrac/telego)
- Tags: how-to-guide
- Published: 2026-03-07

---

**You configure Telego’s HTTP client by passing `telego.WithFastHTTPClient()` for high-performance FastHTTP or `telego.WithHTTPClient()` for standard net/http flexibility to `telego.NewBot()`, which sets the internal `Caller` interface implementation used for all Telegram Bot API requests.**

The `mymmrac/telego` library abstracts all Telegram Bot API network operations behind a `Caller` interface, allowing you to choose between high-performance FastHTTP or the standard library's `net/http`. By default, Telego uses FastHTTP, but you can explicitly select either implementation during bot initialization to optimize for raw speed or networking flexibility without changing your bot logic.

## Understanding the Caller Interface Architecture

Telego decouples Bot API communication from specific HTTP implementations through the `Caller` interface defined in [`telegoapi/caller.go`](https://github.com/mymmrac/telego/blob/main/telegoapi/caller.go). The library ships with two concrete implementations:

- **`FastHTTPCaller`** ([`telegoapi/caller.go`](https://github.com/mymmrac/telego/blob/main/telegoapi/caller.go) lines 30-80): Wraps `github.com/valyala/fasthttp` for minimal allocations and maximum throughput.
- **`HTTPCaller`** ([`telegoapi/caller.go`](https://github.com/mymmrac/telego/blob/main/telegoapi/caller.go) lines 92-130): Wraps the standard `net/http` package for broad compatibility with middleware, proxies, and HTTP/2.

The active caller is stored in `bot.api` and invoked by all API methods like `GetMe` and `SendMessage`. Both implementations support the same retry logic via `RetryCaller`, ensuring consistent error handling regardless of transport choice.

## Configuring FastHTTP for High-Performance Bots

To explicitly use FastHTTP or provide a custom configuration, pass `WithFastHTTPClient` defined in [`bot_options.go`](https://github.com/mymmrac/telego/blob/main/bot_options.go) (lines 23-28):

```go
func WithFastHTTPClient(client *fasthttp.Client) BotOption {
    return func(bot *Bot) error {
        bot.api = ta.FastHTTPCaller{Client: client}
        return nil
    }
}

```

**Example: Bot with custom FastHTTP client**

```go
package main

import (
	"context"
	"log"
	"os"
	"time"

	"github.com/valyala/fasthttp"
	"github.com/mymmrac/telego"
)

func main() {
	bot, err := telego.NewBot(
		os.Getenv("TOKEN"),
		telego.WithFastHTTPClient(&fasthttp.Client{
			MaxIdleConnDuration: 5 * time.Minute,
			ReadTimeout:         10 * time.Second,
		}),
	)
	if err != nil {
		log.Fatal(err)
	}

	me, err := bot.GetMe(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Bot @%s is running", me.Username)
}

```

## Configuring Standard net/http for Flexibility

For scenarios requiring HTTP/2, proxy support, or custom transports, use `WithHTTPClient` from [`bot_options.go`](https://github.com/mymmrac/telego/blob/main/bot_options.go) (lines 31-36):

```go
func WithHTTPClient(client *http.Client) BotOption {
    return func(bot *Bot) error {
        bot.api = ta.HTTPCaller{Client: client}
        return nil
    }
}

```

**Example: Bot with proxy and TLS configuration**

```go
package main

import (
	"context"
	"log"
	"net/http"
	"net/url"
	"os"
	"time"

	"github.com/mymmrac/telego"
)

func main() {
	proxyURL, _ := url.Parse("http://proxy.example.com:3128")
	
	httpClient := &http.Client{
		Transport: &http.Transport{
			Proxy: http.ProxyURL(proxyURL),
		},
		Timeout: 15 * time.Second,
	}

	bot, err := telego.NewBot(
		os.Getenv("TOKEN"),
		telego.WithHTTPClient(httpClient),
	)
	if err != nil {
		log.Fatal(err)
	}

	if _, err := bot.GetMe(context.Background()); err != nil {
		log.Fatal(err)
	}
	log.Println("Bot connected successfully via proxy")
}

```

## FastHTTP vs net/http: Performance and Compatibility

| Aspect | FastHTTP | net/http |
|--------|----------|----------|
| **Performance** | Zero-allocation, higher throughput for concurrent requests | Standard allocations, sufficient for moderate load |
| **HTTP/2** | Not supported | Native support |
| **Proxy Support** | Manual implementation required | Built-in via `http.Transport.Proxy` |
| **TLS Configuration** | Limited options | Full control via `tls.Config` |
| **Memory Usage** | Lower | Higher due to `http.Request/Response` allocations |
| **Use Case** | High-frequency polling, webhook servers | Corporate proxies, HTTP/2 requirements, complex networking |

Both implementations support the `RetryCaller` wrapper for automatic retries, so switching between them does not require changes to error handling logic.

## Implementing a Custom Caller

If neither built-in client meets your requirements, implement the `Caller` interface and inject it via `WithAPICaller`:

```go
type Caller interface {
    Call(ctx context.Context, method string, params url.Values, data telegoapi.InputFile) (*telegoapi.Response, error)
}

```

This approach is ideal for testing with mocks or integrating specialized HTTP libraries that handle specific enterprise requirements.

## Summary

- Telego abstracts HTTP transport through the `Caller` interface defined in [`telegoapi/caller.go`](https://github.com/mymmrac/telego/blob/main/telegoapi/caller.go).
- **FastHTTP** (`WithFastHTTPClient`) provides zero-allocation performance for high-load bots and is the default choice.
- **net/http** (`WithHTTPClient`) offers full compatibility with proxies, HTTP/2, and custom transports for enterprise networks.
- Both implementations are configured via `BotOption` functions in [`bot_options.go`](https://github.com/mymmrac/telego/blob/main/bot_options.go) during `NewBot` initialization.
- You can implement custom transports by satisfying the `Caller` interface and using `WithAPICaller`.

## Frequently Asked Questions

### How do I switch from FastHTTP to net/http in an existing Telego bot?

Replace `telego.WithFastHTTPClient(...)` with `telego.WithHTTPClient(&http.Client{...})` in your `telego.NewBot` call. All subsequent API calls like `GetMe` and `SendMessage` will automatically use the standard library transport without requiring changes to your business logic.

### Does Telego support HTTP/2 for Telegram Bot API calls?

HTTP/2 is only supported when using the `net/http` client. FastHTTP does not implement HTTP/2, so if you require HTTP/2 features, configure your bot with `telego.WithHTTPClient` using an `http.Client` with `ForceAttemptHTTP2: true` in the transport.

### Can I use a proxy with Telego?

Yes, but only with the standard `net/http` client. Pass a custom `http.Client` configured with `Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}` to `telego.WithHTTPClient`. FastHTTP requires manual proxy handling and is not recommended for scenarios requiring standard proxy support.

### Is FastHTTP the default HTTP client in Telego?

Yes, Telego defaults to FastHTTP (`FastHTTPCaller`) when you create a bot with `telego.NewBot` without specifying client options. This provides optimal out-of-the-box performance for typical bot workloads, though you can override it by explicitly passing `telego.WithHTTPClient` or a custom `WithAPICaller`.