Prevent getting old updates from Telegram Bot API using a web hook – Telegram API

The best way is to use update_id which is a specific number that increases on every new request (i.e. update). How to implement it?

First off, let’s start with the following anonymous class (using PHP7):

$lastUpdateId = new class()
{
    const FILE_PATH = "last-update-id.txt";
    private $value = 1;

    public function __construct()
    {
        $this->ensureFileExists();
        $this->value = filesize(self::FILE_PATH) == 0
            ? 0 : (int)(file_get_contents(self::FILE_PATH));
    }

    public function set(int $lastUpdateId)
    {
        $this->ensureFileExists();
        file_put_contents(self::FILE_PATH, $lastUpdateId);
        $this->value = $lastUpdateId;
    }

    public function get(): int
    {
        return $this->value;
    }

    public function isNewRequest(int $updateId): bool
    {
        return $updateId > $this->value;
    }

    private function ensureFileExists()
    {
        if (!file_exists(self::FILE_PATH)) {
            touch(self::FILE_PATH);
        }
    }
};

What the class does is clear: Handling the last update_id via a plain file.

Note: The class is tried to be as short as possible. It does not provide error-checking. Use your custom implementation (e.g. use SplFileObject instead of file_{get|put}_contents() functions) instead.

Now, there are two methods of getting updates: Long Polling xor WebHooks (check Telegram bot API for more details on each methods and all JSON properties). The above code (or similar) should be used in both cases.

Note: Currently, it is impossible to use both methods at the same time.

Long Polling Method (default)

This way, you send HTTPS requests to Telegram bot API, and you’d get updates as response in a JSON-formatted object. So, the following work can be done to get new updates (API, why using offset):

$botToken = "<token>";

$updates = json_decode(file_get_contents("https://api.telegram.org/bot{$botToken}/getUpdates?offset={$lastUpdateId->get()}"), true);

// Split updates from each other in $updates
// It is considered that one sample update is stored in $update

// See the section below
parseUpdate($update);

WebHook Method (preferred)

Requiring support for HTTPS POST method from your server, the best way of getting updates at-the-moment.

Initially, you must enable WebHooks for your bot, using the following request (more details):

https://api.telegram.org/bot<token>/setWebhook?url=<file>

Replace <token> with you bot token, and <file> with the address of your file which is going to accept new requests. Again, it must be HTTPS.

OK, the last step is creating your file at the specified URL:

// The update is sent
$update = $_POST;

// See the section below
parseUpdate($update);

From now, all requests and updates your bot will be directly sent to the file.

Implementation of parseUpdate()

Its implementation is totally up to you. However, to show how to use the class above in the implementation, this is a sample and short implementation for it:

function parseUpdate($update)
{
    // Validate $update, first
    // Actually, you should have a validation class for it

    // Here, we suppose that: $update["update_id"] !== null
    if ($lastUpdateId->isNewRequest($update["update_id"])) {
        $lastUpdateId->set($update["update_id"]);
        // New request, go on
    } else {
        // Old request (or possible file error)
        // You may throw exceptions here
    }
}

Enjoy!

Edit: Thanks to @Amir for suggesting editions made this answer more complete and useful.