Rate Limiting és Kvóták

Ismerje meg a Smart Money API rate limitjeit, a napi kvótákat minden előfizetési szinthez, és az optimalizálási stratégiákat az API használat maximalizálásához.

Áttekintés

A Smart Money API napi kéréskvótákat alkalmaz a szolgáltatás minőségének és az összes felhasználó közötti igazságosság biztosítására. Minden előfizetési szint eltérő napi korláttal rendelkezik. Ha túllépi a napi kvótáját, 429 Too Many Requests hibát kap, amíg a kvóta UTC éjfélkor vissza nem állítódik.

A rate limitek API kulcs szerint érvényesek. Minden kulcs saját független kvótával rendelkezik. Több kulcsot is generálhat különböző alkalmazásokhoz, és külön-külön figyelheti a használatot.

Kvóták Előfizetési Szint Szerint

Szint	Napi Kérések	Ár	Funkciók
Ingyenes	20 kérés/nap	$0	BTC, ETH, SOL, funding rates, liquidations
Trader	400 kérés/nap	$29/hó	Minden szimbólum, bálnák pozíciói, OI adatok
Pro	4,000 kérés/nap	$79/hó	Megerősítési pontszámok, on-chain adatok, webhookok
Enterprise	Egyedi	Egyedi	Dedikált támogatás, egyedi integrációk

Rate Limit Válasz Fejlécek

Minden API válasz tartalmaz fejléceket, amelyek az aktuális kvóta állapotát jelzik:

HTTP Fejlécek

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

Fejléc	Leírás
`X-Requests-Limit`	Napi engedélyezett kérések száma (pl. 200 a Trader szinthez)
`X-Requests-Remaining`	Aktuális napon maradt kérések száma
`X-Requests-Reset`	Unix időbélyeg, amikor a kvóta visszaáll
`X-Requests-Reset-ISO`	ISO 8601 időbélyeg a kvóta visszaállításához

Kvóta Ellenőrzése Kérés Küldése Előtt

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"Quota: {remaining}/{limit} requests ({percent_used:.1f}% used)")
    print(f"Resets at: {reset_time}")

    if remaining < 5:
        print("WARNING: Approaching quota limit!")
        return False

    return True

# Check before making requests
if check_quota_before_request("sk_live_abc123xyz789"):
    print("Safe to proceed with API calls")

Napi Rate Ablak

A rate limitek 24 órás gördülő ablakon működnek. A kvótád naponta UTC éjfélkor (00:00 UTC) visszaáll. A pontos visszaállítási idő a X-Requests-Reset-ISO fejlécben található.

Példa: Trader Szint (400 kérés/nap)

1. nap (Márc. 21): 200 kérés elérhető 00:00 UTC-kor
10:30 UTC: 75 kérés történt, 125 maradt
15:45 UTC: 100 további kérés történt, 25 maradt
23:59 UTC: Még mindig 25 kérés maradt (nem vihető át)
2. nap (Márc. 22, 00:00 UTC): A kvóta visszaáll 200-ra

Optimalizálási Stratégiák

1. API Válaszok Gyorsítótárazása

A bálnák pozíciói nem változnak másodpercenként. Gyorsítótárazza az eredményeket 30-60 másodpercig, és szolgálja ki a gyorsítótárazott adatokat új API hívások helyett.

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()

        # Return cached data if still fresh
        if cache_key in self.cache:
            age = now - self.cache_time[cache_key]
            if age < self.cache_ttl:
                print(f"Served from cache (age: {age:.1f}s)")
                return self.cache[cache_key]

        # Fetch fresh data
        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

# Usage: Cache for 60 seconds
client = CachedClient("sk_live_abc123xyz789", cache_ttl=60)
whales1 = client.get_whale_positions("BTCUSDT")  # API call
whales2 = client.get_whale_positions("BTCUSDT")  # From cache
whales3 = client.get_whale_positions("BTCUSDT")  # From cache

2. WebSocket Használata Valós Idejű Adatokhoz

A WebSocket kapcsolatok azonnali frissítéseket szállítanak anélkül, hogy a rate limitet érintenék. Iratkozzon fel streamekre, és kapjon frissítéseket, ahogy történnek, csökkentve a szükséges REST API hívások számát.

3. Kérések Stratégiai Kötegelése

Ha lehetséges, egy kéréssel több szimbólumot is kérjen le külön kérések helyett. Ez akár 10-szeresére csökkentheti az API hívások számát.

4. Szűrés Használata Kéréskor

Alkalmazzon szűrőket (szimbólum, tőzsde, min_position_size) lekérdezési paraméterekben, hogy pontosan a szükséges adatokat kapja, elkerülve az utófeldolgozást.

Rate Limit Hibák Kezelése

Exponenciális Backoff-fal Próbálkozzon Újra

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:
                # Rate limited - back off exponentially
                wait_time = min(2 ** attempt, 300)  # Max 5 minutes
                reset_time = response.headers.get("X-Requests-Reset-ISO")
                print(f"Rate limited. Retrying in {wait_time}s (resets at {reset_time})")
                time.sleep(wait_time)

            elif response.status_code >= 500:
                # Server error - retry
                wait_time = 2 ** attempt
                print(f"Server error {response.status_code}. Retrying in {wait_time}s")
                time.sleep(wait_time)
            else:
                # Other error - don't retry
                raise Exception(f"HTTP {response.status_code}: {response.text}")

        except requests.exceptions.Timeout:
            wait_time = 2 ** attempt
            print(f"Timeout. Retrying in {wait_time}s")
            time.sleep(wait_time)

    raise Exception("Max retries exceeded")

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

Készen áll a frissítésre?

Az ingyenes szint nem elég? Frissítsen Trader vagy Pro szintre magasabb kvótákért és olyan fejlett funkciókért, mint a megerősítési pontszámok és az on-chain adatok.

Árazás Megtekintése

Optimalizálja API Használatát Ma

Implementáljon gyorsítótárazást, használjon WebSocket-et valós idejű adatokhoz, és kezelje a rate limiteket elegánsan.

Dokumentáció Olvasása

Kezdje ingyen — 100 hívás/nap, kártya nélkül

Kapjon élő bálnák áramlását, fundingot, nyitott kamatot és on-chain adatokat 3 tőzsdéről egy API-ból. Ingyenes szint, hitelkártya nélkül, frissítsen bármikor.

Kezdje ingyen →

Próbálja ki az élő API konzolt → (nincs szükség fiókra)

Szerezze meg API kulcsát 30 másodperc alatt

Készen áll az építésre? Szerezzen egy ingyenes API kulcsot (100 hívás/nap, kártya nélkül), és kezdje el az élő bálnák, funding és on-chain adatok lekérését.

Szerezze meg API kulcsát →