Begränsning av anrop och kvoter

Förstå Smart Money API:s anropsbegränsningar, dagliga kvoter för varje prenumerationsnivå och optimeringsstrategier för att maximera din API-användning.

Översikt

Smart Money API tillämpar dagliga anropskvoter för att säkerställa servicekvalitet och rättvisa för alla användare. Varje prenumerationsnivå har en olik daglig gräns. När du överskrider din dagliga kvot får du ett 429 Too Many Requests-fel tills din kvot återställs vid midnatt UTC.

Anropsbegränsningar tillämpas per API-nyckel. Varje nyckel har sin egen oberoende kvot. Du kan generera flera nycklar för olika applikationer och övervaka användningen för var och en separat.

Kvoter per prenumerationsnivå

Nivå	Dagliga anrop	Pris	Funktioner
Gratis	200 anrop/dag	$0	BTC, ETH, SOL, finansieringsräntor, likvidationer
Handlare	1,000 anrop/dag	$29/månad	Alla symboler, valjepositioner, OI-data
Pro	5 000 anrop/dag	$79/månad	Bekräftelsepoäng, on-chain-data, webhooks
Enterprise	Anpassad	Anpassad	Dedikerad support, anpassade integrationer

Svarhuvuden för anropsbegränsning

Varje API-svar inkluderar huvuden som visar din aktuella kvotstatus:

HTTP-huvuden

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

Huvud	Beskrivning
`X-Requests-Limit`	Totalt antal tillåtna anrop per dag (t.ex. 200 för Handlare)
`X-Requests-Remaining`	Återstående anrop under aktuell dag
`X-Requests-Reset`	Unix-tidsstämpel för när kvoten återställs
`X-Requests-Reset-ISO`	ISO 8601-tidsstämpel för kvotåterställning

Kontrollera kvot innan du gör anrop

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"Kvot: {remaining}/{limit} anrop ({percent_used:.1f}% använt)")
    print(f"Återställs vid: {reset_time}")

    if remaining < 5:
        print("VARNING: Närmar dig kvotgräns!")
        return False

    return True

# Kontrollera innan du gör anrop
if check_quota_before_request("sk_live_abc123xyz789"):
    print("Säker att fortsätta med API-anrop")

Dagligt begränsningsfönster

Anropsbegränsningar fungerar i ett rullande 24-timmarsfönster. Din kvot återställs dagligen vid midnatt UTC (00:00 UTC). Den exakta återställningstiden finns i X-Requests-Reset-ISO huvudet.

Exempel: Handlarnivå (1,000 anrop/dag)

Dag 1 (21 mars): 200 anrop tillgängliga vid 00:00 UTC
10:30 UTC: Gjorde 75 anrop, 125 kvar
15:45 UTC: Gjorde 100 fler anrop, 25 kvar
23:59 UTC: Fortfarande 25 anrop kvar (kan inte föras över)
Dag 2 (22 mars, 00:00 UTC): Kvoten återställs till 200

Optimeringsstrategier

1. Cacha API-svar

Valjepositioner ändras inte varje sekund. Cacha resultat i 30-60 sekunder och servera cachad data istället för att göra nya API-anrop.

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

        # Returnera cachad data om den fortfarande är färsk
        if cache_key in self.cache:
            age = now - self.cache_time[cache_key]
            if age < self.cache_ttl:
                print(f"Serverades från cache (ålder: {age:.1f}s)")
                return self.cache[cache_key]

        # Hämta färsk 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

# Användning: Cacha i 60 sekunder
client = CachedClient("sk_live_abc123xyz789", cache_ttl=60)
whales1 = client.get_whale_positions("BTCUSDT")  # API-anrop
whales2 = client.get_whale_positions("BTCUSDT")  # Från cache
whales3 = client.get_whale_positions("BTCUSDT")  # Från cache

2. Använd WebSocket för realtidsdata

WebSocket-anslutningar levererar uppdateringar direkt utan att räknas mot din anropsbegränsning. Prenumerera på strömmar och få uppdateringar när de händer, vilket minskar antalet REST API-anrop som behövs.

3. Batch-anrop strategiskt

Gör ett anrop med flera symboler när det är möjligt istället för separata anrop för varje symbol. Detta minskar API-anropen med upp till 10x.

4. Använd filtrering vid anropstid

Tillämpa filter (symbol, börs, min_position_size) i frågeparametrar för att få exakt den data du behöver, och undvik efterbehandling.

Hantera anropsbegränsningsfel

Försök igen med exponentiell backoff

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:
                # Anropsbegränsad - backa av exponentiellt
                wait_time = min(2 ** attempt, 300)  # Max 5 minuter
                reset_time = response.headers.get("X-Requests-Reset-ISO")
                print(f"Anropsbegränsad. Försöker igen om {wait_time}s (återställs vid {reset_time})")
                time.sleep(wait_time)

            elif response.status_code >= 500:
                # Serverfel - försök igen
                wait_time = 2 ** attempt
                print(f"Serverfel {response.status_code}. Försöker igen om {wait_time}s")
                time.sleep(wait_time)
            else:
                # Annat fel - försök inte igen
                raise Exception(f"HTTP {response.status_code}: {response.text}")

        except requests.exceptions.Timeout:
            wait_time = 2 ** attempt
            print(f"Timeout. Försöker igen om {wait_time}s")
            time.sleep(wait_time)

    raise Exception("Max antal försök uppnått")

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

Redo att uppgradera?

Gratisnivå räcker inte? Uppgradera till Handlare eller Pro för högre kvoter och tillgång till avancerade funktioner som bekräftelsepoäng och on-chain-data.

Visa priser

Optimerad din API-användning idag

Implementera cachning, använd WebSocket för realtidsdata och hantera anropsbegränsningar graciöst.

Läs dokumentation

Börja gratis – 200 anrop/dag, inget kort

Få live valjeflöde, finansiering, öppet intresse och on-chain-data över 3 börser från ett API. Gratisnivå, inget kreditkort, uppgradera när som helst.

Börja gratis →

Prova live API-konsolen → (inget konto behövs)

Få din API-nyckel på 30 sekunder

Redo att bygga? Hämta en gratis API-nyckel (200 anrop/dag, inget kort) och börja hämta live valje-, finansierings- och on-chain-data.

Hämta din API-nyckel →