Гайд по лимитам запросов (Rate Limits) и производительности API AsterDEX

Rate Limits (Лимиты запросов) — это ограничения на количество запросов, которые вы можете отправить к серверу API в течение определенного периода времени (например, 100 запросов в минуту). Когда вы превышаете этот лимит, сервер временно блокирует ваши запросы, возвращая ошибки (например, HTTP 429 Too Many Requests).

Эти ограничения существуют по нескольким причинам:

• Защита от злоупотреблений: Предотвращение DDoS-атак и недобросовестного использования API.
• Справедливое использование: Гарантирует, что все пользователи имеют равный доступ к ресурсам API, и один пользователь не "забивает" канал для всех остальных.
• Стабильность сервера: Поддерживает производительность и стабильность работы API, предотвращая перегрузку.

Для API AsterDEX действует общий лимит на количество запросов:

Максимум: 1200 запросов в минуту на один API-ключ/IP-адрес.

Этот лимит применяется к большинству REST-эндпоинтов. Некоторые эндпоинты могут иметь индивидуальные "веса" или более строгие ограничения (например, размещение и отмена ордеров). Всегда проверяйте актуальную документацию для конкретного эндпоинта.

При превышении лимита вы получите HTTP-статус 429 Too Many Requests. В некоторых случаях может быть установлено временное ограничение (бан) на доступ к API на несколько минут.

1. Используйте WebSocket для потоковых данных

Если вам нужны рыночные данные в реальном времени (цены, сделки, стакан), используйте WebSocket API. Это "push"-модель, где сервер сам отправляет вам обновления, избавляя от необходимости постоянно опрашивать (polling) REST-эндпоинты и тем самым значительно снижая количество запросов. Подробнее о разнице читайте в статье REST vs WebSocket.

2. Реализуйте "Экспоненциальную задержку" (Exponential Backoff)

Если вы получили ошибку 429 Too Many Requests, немедленно не повторяйте запрос. Вместо этого подождите некоторое время, прежде чем повторить попытку. С каждым следующим неудачным повтором увеличивайте время ожидания. Это позволяет API "отдохнуть" и избегает дальнейшей блокировки.

3. Ограничение скорости на стороне клиента (Client-side Throttling)

Внедрите логику ограничения скорости прямо в свой код. Это можно сделать с помощью очереди запросов или просто с помощью задержек (например, `time.sleep()` в Python) между запросами, чтобы убедиться, что вы не отправляете их быстрее, чем это позволяет API.

4. Анализируйте HTTP-заголовки лимитов

Многие API возвращают специальные HTTP-заголовки, которые показывают ваш текущий статус Rate Limit:

• X-RateLimit-Limit: Максимальное количество запросов.
• X-RateLimit-Remaining: Сколько запросов осталось до превышения лимита.
• X-RateLimit-Reset: Время (в секундах или timestamp), когда лимит будет сброшен.

Используйте эти заголовки для динамического управления скоростью отправки запросов вашим ботом.

5. Кешируйте данные

Если данные (например, `exchangeinfo`) меняются редко, загрузите их один раз и сохраните локально, вместо того чтобы запрашивать их при каждом запуске программы или перед каждой торговой операцией.

6. Оптимизируйте запросы

Запрашивайте только те данные, которые вам действительно нужны. Не используйте эндпоинт, который возвращает весь список торговых пар, если вам нужна информация только по одной. Объединяйте запросы, если API это позволяет.

7. Разделяйте API-ключи

Для разных задач (например, получение рыночных данных и управление ордерами) используйте разные API-ключи. Это может помочь изолировать проблемы: если один ключ будет заблокирован из-за превышения лимитов получения данных, вы все равно сможете использовать другой ключ для управления своим портфелем.

Этот пример демонстрирует базовый подход к клиентскому ограничению скорости с использованием задержек.

import time
import requests
from collections import deque

# --- НАСТРОЙКИ ---
BASE_URL = "https://fapi.asterdex.com"
MAX_REQUESTS_PER_MINUTE = 1200
REQUEST_INTERVAL_SECONDS = 60 / MAX_REQUESTS_PER_MINUTE # ~0.05 секунды на запрос

# Очередь для отслеживания времени последнего запроса
request_timestamps = deque()

def controlled_request(method, path, params=None):
    """
    Отправляет HTTP-запрос, соблюдая Rate Limits.
    """
    global request_timestamps

    # Убираем старые метки времени из очереди
    current_time = time.time()
    while request_timestamps and request_timestamps[0] <= current_time - 60:
        request_timestamps.popleft()

    # Если достигнут лимит за минуту, ждем до следующей "разрешенной" секунды
    if len(request_timestamps) >= MAX_REQUESTS_PER_MINUTE:
        time_to_wait = request_timestamps[0] + 60 - current_time
        if time_to_wait > 0:
            print(f"Достигнут Rate Limit. Ожидание {time_to_wait:.2f} секунд...")
            time.sleep(time_to_wait)
            current_time = time.time() # Обновляем текущее время после ожидания
            while request_timestamps and request_timestamps[0] <= current_time - 60:
                request_timestamps.popleft()

    # Ждем, чтобы соблюсти интервал между запросами (если запросов пока немного)
    if request_timestamps:
        last_request_time = request_timestamps[-1]
        time_since_last_request = current_time - last_request_time
        if time_since_last_request < REQUEST_INTERVAL_SECONDS:
            sleep_duration = REQUEST_INTERVAL_SECONDS - time_since_last_request
            print(f"Слишком быстрый запрос. Ожидание {sleep_duration:.2f} секунд...")
            time.sleep(sleep_duration)
            current_time = time.time() # Обновляем текущее время после ожидания

    # Добавляем текущее время в очередь
    request_timestamps.append(current_time)
    
    url = BASE_URL + path
    try:
        if method.upper() == 'GET':
            response = requests.get(url, params=params)
        elif method.upper() == 'POST':
            response = requests.post(url, params=params)
        else:
            return None
        
        response.raise_for_status() # Вызывает HTTPError для плохих ответов (4xx или 5xx)
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Ошибка запроса: {e}")
        # Здесь можно добавить логику экспоненциальной задержки для 429 ошибок
        return None

# Пример использования:
if __name__ == "__main__":
    print(f"Начинаем серию запросов с контролем Rate Limit ({MAX_REQUESTS_PER_MINUTE} в минуту)...")
    for i in range(200): # Отправляем 200 запросов
        print(f"Запрос {i+1}:")
        data = controlled_request('GET', '/fapi/v1/ping')
        if data is not None:
            print(f"  Успех: {data}")
        else:
            print("  Ошибка или превышение лимита.")
        # Небольшая задержка, чтобы не превысить лимит слишком быстро,
        # если REQUEST_INTERVAL_SECONDS очень мало.
        # В реальном коде это не обязательно, т.к. controlled_request уже ждет.
        # time.sleep(0.01)

Эффективное управление Rate Limits — это признак профессионализма и ключ к стабильной и бесперебойной работе с API. Внедряя описанные практики, вы не только избежите блокировок, но и сделаете ваш код более надежным и производительным.

Для дальнейшего изучения работы с API AsterDEX, ознакомьтесь с другими нашими материалами:

• Создание простого торгового бота на Python
• Потоковые данные с WebSocket и Node.js
• HMAC-SHA256 Аутентификация