Limitare de rată și cote

Aflați despre limitele de rată ale Smart Money API, cotele zilnice pentru fiecare nivel de abonament și strategiile de optimizare pentru a vă maximiza utilizarea API.

Prezentare generală

Smart Money API implementează cote zilnice de cereri pentru a asigura calitatea serviciului și echitatea pentru toți utilizatorii. Fiecare nivel de abonament include o limită zilnică diferită. Când depășiți cota zilnică, primiți o eroare 429 Too Many Requests până când cota se resetează la miezul nopții UTC.

Limitele de rată se aplică pe cheie API. Fiecare cheie are propria cotă independentă. Puteți genera mai multe chei pentru diferite aplicații și puteți monitoriza utilizarea pentru fiecare în parte.

Cote pe niveluri de abonament

Nivel	Cereri zilnice	Preț	Caracteristici
Gratuit	20 cereri/zi	$0	BTC, ETH, SOL, rate de funding, lichidări
Trader	400 cereri/zi	$29/lună	Toate simbolurile, poziții de balenă, date OI
Pro	4.000 cereri/zi	$79/lună	Scoruri de confirmare, date on-chain, webhooks
Enterprise	Personalizat	Personalizat	Suport dedicat, integrări personalizate

Antete de răspuns la limită de rată

Fiecare răspuns API include antete care indică starea curentă a cotei dumneavoastră:

Antete HTTP

X-Requests-Limit: 200
X-Requests-Remaining: 147
X-Requests-Reset: 1711116000
X-Requests-Reset-ISO: 2026-03-22T00:00:00Z

Antet	Descriere
`X-Requests-Limit`	Total cereri permise pe zi (de ex., 200 pentru Trader)
`X-Requests-Remaining`	Cereri rămase în ziua curentă
`X-Requests-Reset`	Timestamp Unix când cota se resetează
`X-Requests-Reset-ISO`	Timestamp ISO 8601 pentru resetarea cotei

Verificarea cotei înainte de a face cereri

Python

import requests
from datetime import datetime

def check_quota_before_request(api_key):
    response = requests.head(
        "https://api.smartmoneyapi.com/v1/whales/events",
        headers={"Authorization": f"Bearer {api_key}"}
    )

    limit = int(response.headers.get("X-Requests-Limit", 0))
    remaining = int(response.headers.get("X-Requests-Remaining", 0))
    reset_unix = int(response.headers.get("X-Requests-Reset", 0))

    reset_time = datetime.fromtimestamp(reset_unix)
    percent_used = (limit - remaining) / limit * 100

    print(f"Cotă: {remaining}/{limit} cereri ({percent_used:.1f}% utilizat)")
    print(f"Se resetează la: {reset_time}")

    if remaining < 5:
        print("ATENȚIE: Apropiindu-vă de limita cotei!")
        return False

    return True

# Verifică înainte de a face cereri
if check_quota_before_request("sk_live_abc123xyz789"):
    print("Sigur să continui cu apelurile API")

Fereastră zilnică de rată

Limitele de rată funcționează pe o fereastră glisantă de 24 de ore. Cota dumneavoastră se resetează zilnic la miezul nopții UTC (00:00 UTC). Ora exactă de resetare este furnizată în antetul X-Requests-Reset-ISO .

Exemplu: Nivelul Trader (400 cereri/zi)

Ziua 1 (21 martie): 200 cereri disponibile la 00:00 UTC
10:30 UTC: Au fost făcute 75 de cereri, 125 rămase
15:45 UTC: Au fost făcute încă 100 de cereri, 25 rămase
23:59 UTC: Încă 25 de cereri rămase (nu se pot transfera)
Ziua 2 (22 martie, 00:00 UTC): Cota se resetează la 200

Strategii de optimizare

1. Stocați în cache răspunsurile API

Pozițiile balenelor nu se schimbă în fiecare secundă. Stocați rezultatele în cache pentru 30-60 de secunde și furnizați datele din cache în loc să faceți noi apeluri API.

Python

import requests
import time

class CachedClient:
    def __init__(self, api_key, cache_ttl=60):
        self.api_key = api_key
        self.cache_ttl = cache_ttl
        self.cache = {}
        self.cache_time = {}

    def get_whale_positions(self, symbol):
        cache_key = f"whales:{symbol}"
        now = time.time()

        # Returnează datele din cache dacă sunt încă proaspete
        if cache_key in self.cache:
            age = now - self.cache_time[cache_key]
            if age < self.cache_ttl:
                print(f"Furnizat din cache (vârstă: {age:.1f}s)")
                return self.cache[cache_key]

        # Obține date noi
        response = requests.get(
            f"https://api.smartmoneyapi.com/v1/whales/events?symbol={symbol}",
            headers={"Authorization": f"Bearer {self.api_key}"}
        )

        data = response.json()
        self.cache[cache_key] = data
        self.cache_time[cache_key] = now
        return data

# Utilizare: Cache pentru 60 de secunde
client = CachedClient("sk_live_abc123xyz789", cache_ttl=60)
whales1 = client.get_whale_positions("BTCUSDT")  # Apel API
whales2 = client.get_whale_positions("BTCUSDT")  # Din cache
whales3 = client.get_whale_positions("BTCUSDT")  # Din cache

2. Utilizați WebSocket pentru date în timp real

Conexiunile WebSocket furnizează actualizări instantaneu fără a conta împotriva limitei de rată. Abonați-vă la fluxuri și primiți actualizări pe măsură ce apar, reducând numărul de apeluri REST API necesare.

3. Grupați cererile strategic

Faceți o singură cerere cu mai multe simboluri, când este posibil, în loc de cereri separate pentru fiecare simbol. Acest lucru reduce apelurile API de până la 10 ori.

4. Utilizați filtrarea la momentul cererii

Aplicați filtre (simbol, exchange, dimensiune_minimă_poziție) în parametrii de interogare pentru a obține exact datele de care aveți nevoie, evitând necesitatea post-procesării.

Gestionarea erorilor de limită de rată

Reîncercați cu backoff exponențial

Python

import requests
import time

def request_with_retry(url, api_key, max_retries=5):
    for attempt in range(max_retries):
        try:
            response = requests.get(
                url,
                headers={"Authorization": f"Bearer {api_key}"},
                timeout=10
            )

            if response.status_code == 200:
                return response.json()

            elif response.status_code == 429:
                # Limită de rată - backoff exponențial
                wait_time = min(2 ** attempt, 300)  # Max 5 minute
                reset_time = response.headers.get("X-Requests-Reset-ISO")
                print(f"Limită de rată. Reîncercare în {wait_time}s (se resetează la {reset_time})")
                time.sleep(wait_time)

            elif response.status_code >= 500:
                # Eroare de server - reîncercare
                wait_time = 2 ** attempt
                print(f"Eroare de server {response.status_code}. Reîncercare în {wait_time}s")
                time.sleep(wait_time)
            else:
                # Altă eroare - nu reîncercați
                raise Exception(f"HTTP {response.status_code}: {response.text}")

        except requests.exceptions.Timeout:
            wait_time = 2 ** attempt
            print(f"Timeout. Reîncercare în {wait_time}s")
            time.sleep(wait_time)

    raise Exception("Maxim de reîncercări depășit")

# Utilizare
data = request_with_retry(
    "https://api.smartmoneyapi.com/v1/whales/events",
    "sk_live_abc123xyz789"
)
print(data)

Gata să faceți upgrade?

Nivelul gratuit nu este suficient? Faceți upgrade la Trader sau Pro pentru cote mai mari și acces la funcții avansate precum scoruri de confirmare și date on-chain.

Vezi prețurile

Optimizați-vă utilizarea API astăzi

Implementați cache, utilizați WebSocket pentru date în timp real și gestionați limitele de rată cu grație.

Citește documentația

Începe gratuit — 200 apeluri/zi, fără card

Obțineți flux live de balene, funding, open interest și date on-chain de la 3 exchange-uri dintr-un singur API. Nivel gratuit, fără card de credit, upgrade oricând.

Începe gratuit →

Încearcă consola live API → (fără cont necesar)

Obține cheia API în 30 de secunde

Gata să construiești? Ia o cheie API gratuită (200 apeluri/zi, fără card) și începe să obții date live despre balene, funding și on-chain.

Obține cheia API →