ការកំណត់អត្រា និងកូតា

យល់ដឹងអំពីដែនកំណត់អត្រា Smart Money API កូតាប្រចាំថ្ងៃសម្រាប់ថ្នាក់ការជាវនីមួយៗ និងយុទ្ធសាស្ត្រធ្វើឱ្យប្រសើរដើម្បីបង្កើនការប្រើប្រាស់ API របស់អ្នក។

ទិដ្ឋភាពទូទៅ

Smart Money API អនុវត្តកូតាសំណើប្រចាំថ្ងៃដើម្បីធានាគុណភាពសេវាកម្ម និងយុត្តិធម៌សម្រាប់អ្នកប្រើប្រាស់ទាំងអស់។ ថ្នាក់ការជាវនីមួយៗមានដែនកំណត់ប្រចាំថ្ងៃខុសៗគ្នា។ នៅពេលអ្នកលើសពីកូតាប្រចាំថ្ងៃរបស់អ្នក អ្នកនឹងទទួលកំហុស 429 Too Many Requests រហូតដល់កូតារបស់អ្នកត្រឡប់មកវិញនៅពេលអាធ្រាត្រ UTC។

ដែនកំណត់អត្រាត្រូវបានអនុវត្តតាមសោ API នីមួយៗ។ សោនីមួយៗមានកូតាឯករាជ្យផ្ទាល់ខ្លួន។ អ្នកអាចបង្កើតសៅច្រើនសម្រាប់កម្មវិធីផ្សេងៗគ្នា និងតាមដានការប្រើប្រាស់សម្រាប់គ្នាទៅវិញទៅមក។

កូតាតាមថ្នាក់ការជាវ

ថ្នាក់	សំណើប្រចាំថ្ងៃ	តម្លៃ	លក្ខណៈពិសេស
ឥតគិតថ្លៃ	200 requests/day	$0	BTC, ETH, SOL, funding rates, liquidations
អ្នកជំនួញ	1,000 requests/day	$29/month	សញ្ញាទាំងអស់ ទីតាំងអ្នកលក់ដុំ ទិន្នន័យ OI
អ្នកជំនាញ	5,000 requests/day	$79/month	ពិន្ទុបញ្ជាក់ ទិន្នន័យលើខ្សែសង្វាក់ webhooks
សហគ្រាស	កំណត់ផ្ទាល់ខ្លួន	កំណត់ផ្ទាល់ខ្លួន	ការគាំទ្រដោយផ្តាច់មុខ ការរួមបញ្ចូលផ្ទាល់ខ្លួន

ក្បាលឆ្លើយតបដែនកំណត់អត្រា

រាល់ការឆ្លើយតប API រួមបញ្ចូលក្បាលដែលបង្ហាញស្ថានភាពកូតាបច្ចុប្បន្នរបស់អ្នក៖

ក្បាល HTTP

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

ក្បាល	ការពិពណ៌នា
`X-Requests-Limit`	សំណើសរុបដែលអនុញ្ញាតក្នុងមួយថ្ងៃ (ឧទាហរណ៍ 200 សម្រាប់អ្នកជំនួញ)
`X-Requests-Remaining`	សំណើដែលនៅសល់ក្នុងថ្ងៃបច្ចុប្បន្ន
`X-Requests-Reset`	ពេលវេលា Unix នៅពេលកូតាត្រឡប់មកវិញ
`X-Requests-Reset-ISO`	ពេលវេលា ISO 8601 សម្រាប់កូតាត្រឡប់មកវិញ

ការពិនិត្យកូតាមុនពេលធ្វើសំណើ

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

បង្អួចអត្រាប្រចាំថ្ងៃ

ដែនកំណត់អត្រាដំណើរការលើបង្អួចវិល 24 ម៉ោង។ កូតារបស់អ្នកត្រឡប់មកវិញរាល់ថ្ងៃនៅអាធ្រាត្រ UTC (00:00 UTC)។ ពេលវេលាត្រឡប់មកវិញពិតប្រាកដត្រូវបានផ្តល់ឱ្យក្នុង X-Requests-Reset-ISO ក្បាល។

ឧទាហរណ៍៖ ថ្នាក់អ្នកជំនួញ (1,000 requests/day)

ថ្ងៃទី 1 (ថ្ងៃទី 21 ខែមីនា)៖ 200 requests ដែលអាចប្រើបាននៅ 00:00 UTC
10:30 UTC៖ បានធ្វើ 75 requests នៅសល់ 125
15:45 UTC៖ បានធ្វើ 100 requests ទៀត នៅសល់ 25
23:59 UTC៖ នៅតែនៅសល់ 25 requests (មិនអាចយកទៅថ្ងៃបន្ទាប់បានទេ)
ថ្ងៃទី 2 (ថ្ងៃទី 22 ខែមីនា 00:00 UTC)៖ កូតាត្រឡប់មកវិញដល់ 200

យុទ្ធសាស្ត្រធ្វើឱ្យប្រសើរ

1. ឃ្លាំងសំណើ API

ទីតាំងអ្នកលក់ដុំមិនផ្លាស់ប្តូររាល់វិនាទីទេ។ ឃ្លាំងលទ្ធផលសម្រាប់ 30-60 វិនាទី ហើយផ្តល់ទិន្នន័យដែលបានឃ្លាំងជំនួសឱ្យការធ្វើការហៅ 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()

        # 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 សម្រាប់ទិន្នន័យពេលវេលាពិត

ការតភ្ជាប់ WebSocket ផ្តល់ឱ្យនូវការអាប់ដេតភ្លាមៗ ដោយមិនរាប់បញ្ចូលក្នុងដែនកំណត់អត្រារបស់អ្នកទេ។ ជាវខ្សែស្ទ្រីម និងទទួលការអាប់ដេតនៅពេលដែលវាកើតឡើង ដោយបន្ថយចំនួនការហៅ REST API ដែលត្រូវការ។

3. ធ្វើសំណើជាក្រុមយ៉ាងយុត្តិធម៌

ធ្វើសំណើមួយដែលមានសញ្ញាច្រើននៅពេលដែលអាចធ្វើបាន ជំនួសឱ្យការធ្វើសំណើដាច់ដោយឡែកសម្រាប់សញ្ញានីមួយៗ។ វាបន្ថយការហៅ API ដល់ 10 ដង។

4. ប្រើការត្រងនៅពេលធ្វើសំណើ

អនុវត្តតម្រង (សញ្ញា ការផ្លាស់ប្តូរ ទំហំទីតាំងអប្បបរមា) ក្នុងប៉ារ៉ាម៉ែត្រសំណួរ ដើម្បីទទួលបានទិន្នន័យដែលអ្នកត្រូវការពិតប្រាកដ ដោយជៀសវាងការត្រូវការការដំណើរការបន្ទាប់។

ការដោះស្រាយកំហុសដែនកំណត់អត្រា

ព្យាយាមម្តងទៀតដោយការពន្យារពេលដោយអិចស្ប៉ូណង់ស្យែល

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)

ត្រៀមខ្លួនដើម្បីដំឡើងកំណែថ្មី?

ថ្នាក់ឥតគិតថ្លៃមិនគ្រប់គ្រាន់ទេ? ដំឡើងកំណែទៅជាថ្នាក់អ្នកជំនួញ ឬអ្នកជំនាញដើម្បីទទួលបានកូតាកាន់តែខ្ពស់ និងការចូលប្រើលក្ខណៈពិសេសកម្រិតខ្ពស់ដូចជាពិន្ទុបញ្ជាក់ និងទិន្នន័យលើខ្សែសង្វាក់។

មើលតម្លៃ

ធ្វើឱ្យប្រសើរការប្រើប្រាស់ API របស់អ្នកថ្ងៃនេះ

អនុវត្តការឃ្លាំង ប្រើ WebSocket សម្រាប់ទិន្នន័យពេលវេលាពិត និងដោះស្រាយដែនកំណត់អត្រាដោយវិជ្ជាជីវៈ។

អានឯកសារ

ចាប់ផ្តើមដោយឥតគិតថ្លៃ — 200 calls/day គ្មានកាត

ទទួលបានលំហូរអ្នកលក់ដុំផ្ទាល់ ការផ្តល់មូលនិធិ ការចាប់អារម្មណ៍បើក និងទិន្នន័យលើខ្សែសង្វាក់ពី 3 ការផ្លាស់ប្តូរពី API តែមួយ។ ថ្នាក់ឥតគិតថ្លៃ គ្មានកាតឥណទាន ដំឡើងកំណែគ្រប់ពេល។

ចាប់ផ្តើមឥតគិតថ្លៃ →

សាកល្បងកុងសោល API ផ្ទាល់ → (មិនត្រូវការគណនី)

ទទួលបានសោ API របស់អ្នកក្នុងរយៈពេល 30 វិនាទី

ត្រៀមខ្លួនដើម្បីសាងសង់? យកសោ API ឥតគិតថ្លៃ (200 calls/day គ្មានកាត) ហើយចាប់ផ្តើមទាញទិន្នន័យអ្នកលក់ដុំផ្ទាល់ ការផ្តល់មូលនិធិ និងទិន្នន័យលើខ្សែសង្វាក់។

ទទួលបានសោ API របស់អ្នក →