# How to Set Update Interval for Telego Long Polling: A Complete Guide

> Learn how to set the update interval for Telego long polling using WithLongPollingUpdateInterval. Enforce delays between getUpdates API calls for efficient Telegram bot development.

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

---

**Use the `WithLongPollingUpdateInterval` option when calling `UpdatesViaLongPolling`, passing a `time.Duration` such as `2 * time.Second` to enforce a minimum delay between consecutive `getUpdates` API calls.**

The `mymmrac/telego` library provides a robust Go interface for the Telegram Bot API, including an efficient long-polling mechanism to receive updates. When implementing production bots, controlling the rate at which your application polls Telegram's servers is crucial for optimizing resource usage and avoiding rate limits. This guide explains how to set update interval for Telego long polling using the options pattern and the internal architecture that makes it work.

## Understanding the Update Interval Configuration

Telego uses an **options pattern** to configure long-polling behavior through the `UpdatesViaLongPolling` method. The `WithLongPollingUpdateInterval` option specifically controls the minimum pause between successful calls to Telegram's `getUpdates` endpoint.

| Option | Default Value | Purpose |
|--------|---------------|---------|
| `WithLongPollingUpdateInterval` | `0` (no delay) | Minimum duration to wait after a successful `GetUpdates` call before issuing the next request |
| `WithLongPollingRetryTimeout` | `8s` | Delay after an error occurs before retrying the connection |
| `WithLongPollingBuffer` | `100` | Size of the internal channel buffer for delivering updates |

When you provide `WithLongPollingUpdateInterval`, the library validates that the duration is non-negative and stores it in the internal `longPolling` struct (see the implementation at lines **30-43** of [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go)). During the polling loop, the code explicitly sleeps for this duration after processing each batch of updates (lines **50-52**).

## Implementing the Update Interval in Code

### Basic Configuration with a 2-Second Interval

To enforce a 2-second pause between polls, pass `WithLongPollingUpdateInterval` as an option to `UpdatesViaLongPolling`:

```go
package main

import (
    "context"
    "log"
    "time"
    
    "github.com/mymmrac/telego"
)

func main() {
    ctx := context.Background()
    bot, err := telego.NewBot("YOUR_BOT_TOKEN")
    if err != nil {
        log.Fatal(err)
    }

    // Configure getUpdates parameters with a 10-second server-side timeout
    params := &telego.GetUpdatesParams{
        Timeout: 10,
    }

    // Start long polling with a 2-second client-side interval between requests
    updates, err := bot.UpdatesViaLongPolling(
        ctx,
        params,
        telego.WithLongPollingUpdateInterval(2*time.Second),
    )
    if err != nil {
        log.Fatalf("Failed to start long polling: %v", err)
    }

    for update := range updates {
        // Process each update
        log.Printf("Received update ID: %d", update.UpdateID)
    }
}

```

*Implementation reference: [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go) lines 30-43.*

### Combining Multiple Long-Polling Options

You can combine the update interval with retry timeouts and buffer size to fine-tune performance:

```go
updates, err := bot.UpdatesViaLongPolling(
    ctx,
    nil, // Use default GetUpdatesParams
    telego.WithLongPollingUpdateInterval(500*time.Millisecond),
    telego.WithLongPollingRetryTimeout(5*time.Second),
    telego.WithLongPollingBuffer(200),
)

```

### Using Custom GetUpdates Parameters

When providing your own `GetUpdatesParams`, ensure you set the `Timeout` field appropriately. The library does not apply the default 8-second timeout when you supply custom parameters:

```go
params := &telego.GetUpdatesParams{
    Timeout: 30, // Wait up to 30 seconds for server-side updates
    AllowedUpdates: []string{"message", "callback_query"},
}

updates, _ := bot.UpdatesViaLongPolling(
    ctx,
    params,
    telego.WithLongPollingUpdateInterval(1*time.Second),
)

```

## Architecture of the Polling Loop

Understanding how Telego implements the update interval helps in debugging performance issues. The polling mechanism follows this flow:

1. **Configuration Phase**: `Bot.createLongPolling` initializes a `longPolling` struct with default values (0s interval, 8s retry timeout, 100 buffer size).
2. **Option Application**: Each `LongPollingOption` function mutates the configuration struct, validating that the update interval is non-negative.
3. **Execution Loop**: In `Bot.doLongPolling`, the bot continuously calls `getUpdates`. After successfully retrieving and dispatching updates to the channel, the code checks `lp.updateInterval`. If greater than zero, it executes `time.Sleep(lp.updateInterval)` before the next iteration.

This implementation ensures that the interval applies only after successful requests, not during error recovery (which uses the separate retry timeout). The design isolates polling concerns from update processing, allowing your bot logic to handle messages independently of rate-limiting logic.

## Summary

- Use `WithLongPollingUpdateInterval(duration)` to enforce a minimum delay between successful `getUpdates` calls.
- The default interval is `0` (no delay), which may cause tight-loop polling if the server responds immediately.
- Pass options as variadic arguments to `UpdatesViaLongPolling` along with your `GetUpdatesParams`.
- The interval is implemented in [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go) via `time.Sleep` after successful update retrieval.
- Combine with `WithLongPollingRetryTimeout` and `WithLongPollingBuffer` for complete control over polling behavior.

## Frequently Asked Questions

### What is the default update interval in Telego?

By default, Telego does not wait between `getUpdates` calls. The `WithLongPollingUpdateInterval` option defaults to `0`, meaning the bot issues the next request immediately after the previous one completes. This behavior is defined in the `longPolling` struct initialization within [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go), specifically at lines 30-43 where the configuration defaults are established.

### How does the update interval differ from the retry timeout?

The update interval (`WithLongPollingUpdateInterval`) applies only after successful requests, creating a deliberate pause between normal polling cycles to prevent API spam. In contrast, the retry timeout (`WithLongPollingRetryTimeout`) activates only when an error occurs, determining how long to wait before attempting to reconnect. According to the source code in [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go) lines 50-52, the sleep logic only executes when the update interval is greater than zero and follows a successful update retrieval.

### Can I use update intervals with webhooks instead of long polling?

No. The `WithLongPollingUpdateInterval` option is specific to the `UpdatesViaLongPolling` method implemented in [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go). If you use `UpdatesViaWebhook`, Telegram pushes updates to your server rather than your bot polling for them, so client-side polling intervals are irrelevant. For webhook deployments, rate limiting should be handled at the HTTP server or reverse proxy level, not through Telego's long-polling configuration options.

### What happens if I set a negative update interval?

The library validates the duration and rejects negative values. In [`long_polling.go`](https://github.com/mymmrac/telego/blob/main/long_polling.go) (lines 30-43), the `WithLongPollingUpdateInterval` function accepts a `time.Duration` and stores it directly in the configuration struct. While the code doesn't explicitly show a panic for negative values, `time.Sleep` with a negative duration returns immediately, effectively behaving like a zero interval. However, best practice dictates using only non-negative durations such as `500 * time.Millisecond` or `2 * time.Second` to ensure predictable polling behavior.