# How to Configure Telego Long Polling Buffer Size for High-Throughput Bots

> Configure Telego long polling buffer size with telego.WithLongPollingBuffer to manage update queues and prevent blocking for high-throughput bots. Optimize your Telegram bot's performance.

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

---

**Set a custom buffer size using `telego.WithLongPollingBuffer(capacity)` when calling `Bot.UpdatesViaLongPolling` to control how many Telegram updates can queue before blocking.**

Telego is a fast, feature-rich Go library for the Telegram Bot API. When processing high volumes of messages via long polling, the **Telego long polling buffer size** determines how many updates can accumulate in the channel before your consumer must catch up, directly impacting throughput and memory usage.

## Understanding the Default Buffer Size

By default, Telego allocates a buffer of **100 updates** for the long polling channel. This value is defined by the internal constant `defaultLongPollingUpdateChanBuffer` in [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go) at lines 13-14.

The buffer is stored in the `longPolling` configuration struct within the field `updateChanBuffer` (lines 22-25). When you call `UpdatesViaLongPolling` without options, the `createLongPolling` helper initializes this field to the default constant (lines 58-62).

## Using WithLongPollingBuffer to Customize Capacity

To override the default, use the functional option `WithLongPollingBuffer`. This option accepts a `uint` representing the desired channel capacity and assigns it to the configuration struct (lines 59-66).

**Method signature:**

```go
func WithLongPollingBuffer(buffer uint) LongPollingOption

```

When `UpdatesViaLongPolling` executes, it creates the update channel using the configured buffer size (lines 88-90):

```go
updatesChan := make(chan Update, lp.updateChanBuffer)

```

## How the Buffer Impacts Update Processing

The buffer size creates a trade-off between **memory consumption** and **resilience to processing delays**.

- **Small buffer (e.g., 10-100):** Lower memory footprint, but if your handler is slow, the channel fills quickly and blocks the polling goroutine, potentially causing missed updates or delayed acknowledgments to Telegram.
- **Large buffer (e.g., 500-1000+):** Absorbs traffic spikes and temporary slowdowns without blocking, but each queued `Update` struct consumes memory until processed.

## Practical Code Examples

### Basic Configuration with Custom Buffer

Set a buffer of 500 updates to handle burst traffic:

```go
ctx := context.Background()
updates, err := bot.UpdatesViaLongPolling(
    ctx,
    nil, // use default GetUpdates parameters
    telego.WithLongPollingBuffer(500),
)
if err != nil {
    log.Fatalf("failed to start long polling: %v", err)
}

for upd := range updates {
    // Process update
    fmt.Printf("Update ID %d received\n", upd.UpdateID)
}

```

### Complete Production Setup

Configure multiple options including buffer size, update interval, and retry timeout as shown in [`examples/updates_long_polling/main.go`](https://github.com/mymmrac/telego/blob/main/examples/updates_long_polling/main.go):

```go
updates, err := bot.UpdatesViaLongPolling(
    context.Background(),
    &telego.GetUpdatesParams{},
    telego.WithLongPollingUpdateInterval(time.Second*0),
    telego.WithLongPollingRetryTimeout(time.Second*8),
    telego.WithLongPollingBuffer(100), // Explicit buffer configuration
)
if err != nil {
    log.Fatal(err)
}

```

### Verifying the Configuration

The library's test suite in [`long_polling_test.go`](https://github.com/mymmrac/telego/blob/main/long_polling_test.go) demonstrates how the option modifies the internal struct:

```go
ctx := &longPolling{}
buffer := uint(1)

err := telego.WithLongPollingBuffer(buffer)(ctx)
require.NoError(t, err)
assert.Equal(t, buffer, ctx.updateChanBuffer)

```

## Summary

- The default **Telego long polling buffer size** is **100 updates**, defined in [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go).
- Override the default using `telego.WithLongPollingBuffer(capacity)` when calling `Bot.UpdatesViaLongPolling`.
- The buffer is created at [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go) lines 88-90 using the configured capacity.
- Larger buffers improve resilience against processing delays but increase memory usage; smaller buffers are more memory-efficient but may block under load.

## Frequently Asked Questions

### What is the default Telego long polling buffer size?

The default buffer size is **100 updates**, defined by the constant `defaultLongPollingUpdateChanBuffer` in [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go) at lines 13-14. This value is used when you call `UpdatesViaLongPolling` without specifying the `WithLongPollingBuffer` option.

### How do I increase the buffer size for high-traffic bots?

Pass `telego.WithLongPollingBuffer(capacity)` as a functional option to `Bot.UpdatesViaLongPolling`, where `capacity` is a `uint` representing your desired queue size (e.g., `500` or `1000`). This allows the channel to absorb burst traffic without blocking the polling goroutine while your handlers process messages.

### What happens when the update channel buffer is full?

When the buffered channel reaches capacity, the long polling goroutine blocks on the send operation until your consumer reads an update from the channel. This delays acknowledgment to Telegram and can cause the bot to miss updates if the blockage persists beyond Telegram's timeout windows, making proper buffer sizing critical for high-throughput scenarios.

### Does a larger buffer consume more memory?

Yes, each queued `Update` struct consumes memory proportional to the size of the Telegram update payload. Increasing the buffer size trades memory consumption for resilience against temporary processing slowdowns. For bots running in memory-constrained environments, monitor actual queue depths and size the buffer to handle typical spikes without over-allocating.