Monitor spread dan funding rate dengan Python
Ringkasan
- Monitor ini adalah program konsol: setiap
meta.freshness_secdetik ia menarik dataset lengkap/arbitrage/spot-spotdan/funding/spread, menyaring baris berdasarkan ambang batas, mencetak tabel, lalu menambahkannya ke file CSV. - Kedua dataset diminta tanpa filter, sehingga datang dengan
ETag: pengulangan denganIf-None-Matchsebelum snapshot berikutnya mengembalikan304tanpa memakai kuota. Pada429dan503, klien menungguRetry-Afterdetik. - Sisa setelah asumsi fee taker 0,1% per sisi adalah spread dikurangi 0,2 poin persentase. Di Pro dan Max, monitor memeriksa ulang tiga pasangan teratas terhadap order book senilai $1.000.
- Batas atasnya 86.400 panggilan per 30 hari di Trial, yaitu 17,28% dari kuota, dan 1.296.000 di Pro dengan pengecekan order book, yaitu 25,92%.
Monitor spread dan funding adalah program yang menarik spread antar-exchange dan spread funding dalam sebuah loop, menyimpan baris di atas ambang batas Anda, dan mencetaknya sebagai tabel di konsol. Monitor di pelajaran ini sekitar 170 baris Python: datanya berasal dari Genesis API, riwayatnya masuk ke file CSV, dan ia tidak membuka transaksi apa pun. Ia juga tidak mengirim notifikasi; bot dengan pesan Telegram dibahas di Bot arbitrase kripto dengan Python.
Rencana polling: endpoint, frekuensi, dan pemakaian panggilan
| Request | Isinya | Kapan |
|---|---|---|
/account/usage | Paket, freshness_sec, rps_limit | Saat mulai, tidak memakai kuota |
/arbitrage/spot-spot | Pasangan Spot – Spot | Setiap putaran, dataset lengkap |
/funding/spread | Pasangan exchange terbaik menurut funding | Setiap putaran, dataset lengkap |
/orderbooks/spreads/spot-spot | Δ order book untuk $1.000 | Pro dan Max, tiga pasangan per putaran |
meta.freshness_sec menentukan frekuensi: paket Anda mendapat snapshot baru setiap 60 detik di Trial, 30 di Start, 10 di Pro, dan 5 di Max. Polling lebih cepat hanya mengembalikan snapshot yang sama dengan meta.updated_at yang sama. Field kedua dataset ada di dokumentasi Spot — Spot dan Spread funding.
| Paket dan kuota | Jeda | Request per putaran | Panggilan per 30 hari |
|---|---|---|---|
| Trial, 500K | 60 dtk | 2 | 86.400 |
| Start, 2M | 30 dtk | 2 | 172.800 |
| Pro, 5M | 10 dtk | 5 | 1.296.000 |
| Max, 10M | 5 dtk | 5 | 2.592.000 |
Di Trial: 2 × 86.400 / 60 × 30 = 86.400 panggilan, 17,28% dari kuota. Di Pro, tiga pengecekan order book bergabung dengan dua dataset: 5 × 86.400 / 10 × 30 = 1.296.000 panggilan, 25,92% dari 5M. Aturan kuota ada di panduan Limit Genesis API.
Monitor menjaga batas request per detik dengan jeda 1,1 / rps_limit detik antar request: 1,1 detik di Trial dan 0,22 di Pro. Satu putaran lima request di Pro memakan waktu sekitar satu detik.
Pengaturan dan klien dengan ETag dan Retry-After
Tujuh blok kode dalam pelajaran ini membentuk seluruh file monitor.py: simpan satu per satu dalam satu file. Ambang batas di pengaturan hanya contoh; sesuaikan dengan fee dan ukuran Anda.
import csv
import os
import time
from datetime import datetime, timezone
import requests
API = "https://api.genesisarbitrage.com/v1"
MIN_SPREAD = 1.0 # spread dari 1%
MIN_VOLUME = 50_000 # volume 24 jam di kedua exchange dari $50.000
MIN_FUNDING = 0.05 # spread funding dari 0,05%
FEE = 0.1 # asumsi fee taker per sisi, %
TOP = 10 # jumlah baris di tiap tabel
BOOK_TOP = 3 # pasangan yang dicek ke order book per putaran, Pro/Max
BOOK_USD = 1000 # ukuran cek order book, USD
CSV_FILE = "monitor.csv"
api = requests.Session()
api.headers["X-API-Key"] = os.environ["GENESIS_API_KEY"]
cache = {} # request -> (ETag, isi respons)
stats = {200: 0, 304: 0} # jumlah respons 200 dan 304 yang diterima
pace = {"gap": 1.1, "last": 0.0} # jeda antar request, detik
Kunci berasal dari variabel lingkungan GENESIS_API_KEY dan dikirim di header X-API-Key pada setiap request, tidak pernah di URL. cache menyimpan ETag dan isi respons terakhir untuk tiap request, stats menghitung respons 200 dan 304, dan pace mengingat kapan request terakhir dikirim.
def get(path, params=None):
"""GET ke Genesis API: pengaturan jeda, ETag, dan retry sesuai Retry-After."""
key = (path, tuple(sorted((params or {}).items())))
for _ in range(4): # satu request dan maksimal tiga kali retry
wait = pace["last"] + pace["gap"] - time.monotonic()
if wait > 0:
time.sleep(wait) # maksimal rps_limit request per detik
pace["last"] = time.monotonic()
hdr = {"If-None-Match": cache[key][0]} if key in cache else {}
r = api.get(API + path, params=params, headers=hdr,
timeout=15)
if r.status_code == 304: # snapshot tidak berubah
stats[304] += 1
return cache[key][1]
if r.status_code in (429, 503):
wait = int(r.headers.get("Retry-After", "5"))
if wait > 60: # beginilah tampilan kuota yang habis
raise SystemExit(f"Kuota habis: tunggu {wait} detik")
time.sleep(wait)
continue
r.raise_for_status() # 400, 401, 403: retry tidak akan membantu
stats[200] += 1
body = r.json()
if "ETag" in r.headers: # hanya dataset lengkap yang memilikinya
cache[key] = (r.headers["ETag"], body)
return body
raise RuntimeError("API sibuk, coba lagi di putaran berikutnya")
ETag adalah label versi snapshot. get mengirimnya kembali di header If-None-Match, dan selama snapshot belum berubah server menjawab 304 tanpa isi: kuota tidak terpakai, dan fungsi mengembalikan isi sebelumnya. Pada 429 dan 503 ia menunggu Retry-After detik lalu mencoba lagi, dan jeda lebih dari semenit berarti kuota periode habis, sehingga monitor berhenti. Kode error dan aturan retry ada di panduan Respons dan error Genesis API.
Spread dan funding: memuat, ambang batas, dan pengurutan
def spot_rows():
"""Pasangan Spot – Spot di atas ambang, koin bisa ditransfer."""
body = get("/arbitrage/spot-spot") # tanpa filter: ada ETag
rows = []
for x in body["data"]:
vol = min(x["volume_24h_buy"] or 0, x["volume_24h_sell"] or 0)
if (x["spread_pct"] >= MIN_SPREAD and vol >= MIN_VOLUME
and x["withdraw_enabled_buy"]
and x["deposit_enabled_sell"]):
rows.append({**x, "net": net(x["spread_pct"])})
rows.sort(key=lambda x: x["spread_pct"], reverse=True)
return rows[:TOP], body["meta"]
def funding_rows():
"""Koin dengan spread funding terlebar."""
body = get("/funding/spread") # tanpa filter: ada ETag
rows = [x for x in body["data"] if x["spread_pct"] >= MIN_FUNDING]
rows.sort(key=lambda x: x["spread_pct"], reverse=True)
return rows[:TOP], body["meta"]
Kedua dataset diminta tanpa parameter: respons untuk request dengan min_spread, coin, atau filter lain dibuat khusus untuk request itu dan datang tanpa ETag. Monitor menerapkan ambang batas sendiri: spread minimal MIN_SPREAD, volume 24 jam minimal MIN_VOLUME di kedua exchange, penarikan terbuka di exchange beli, dan deposit terbuka di exchange jual. Volume null dianggap nol, sehingga baris seperti itu tidak lolos.
Baris diurutkan menurut spread_pct dari yang terbesar, dan TOP baris pertama masuk ke tabel. Di /funding/spread, ambang MIN_FUNDING dibandingkan dengan spread_pct pasangan terbaik.
Sisa setelah fee dan pengecekan order book
def net(spread_pct):
"""Sisa setelah dua fee taker, perkiraan, %."""
return round(spread_pct - 2 * FEE, 4)
def book_net(row):
"""Sisa setelah BOOK_USD order book dan fee. Pro dan Max."""
body = get("/orderbooks/spreads/spot-spot",
{"coin": row["coin"], "volume": BOOK_USD})
pair = (row["exchange_buy"], row["exchange_sell"])
for x in body["data"]:
if (x["exchange_buy"], x["exchange_sell"]) != pair:
continue
od = x["order_delta"]
if od["status"] != "ok":
return od["status"] # no_book atau exhausted
return net(od["spread_pct"])
return "gone" # pasangan sudah keluar dari dataset
Asumsi fee taker 0,1% saat beli dan 0,1% saat jual memangkas spread sekitar 0,2 poin persentase: pasangan 1,62% menyisakan 1,62 − 2 × 0,1 = 1,42%. Isi FEE dengan fee exchange Anda (maker dan taker). Fee penarikan tidak ada di respons API, dan monitor tidak memperhitungkannya.
Di Pro dan Max, book_net memeriksa ulang tiga pasangan teratas terhadap order book: /orderbooks/spreads/spot-spot dengan koin pasangan itu dan volume=1000 mengembalikan baris koin tersebut dengan objek order_delta, dan fungsi mengambil baris dengan pasangan exchange yang sama (Δ order book). Jika tidak ada book atau book habis, Anda mendapat status no_book atau exhausted, bukan angka. Request dengan coin tidak punya ETag dan selalu memakai satu panggilan, karena itu satu putaran hanya membuat tiga request seperti itu, sesuai BOOK_TOP.
Tabel konsol
def show(spot, s_meta, fund, f_meta):
now = time.time()
s_age = now - s_meta["updated_at"]
f_age = now - f_meta["updated_at"]
print(f"\nSpot – Spot, usia snapshot {s_age:.0f} detik")
print(f"{'Koin':<8}{'Beli → jual':<20}"
f"{'Spread':>7}{'-fee':>9}{'Book':>11}")
for x in spot:
pair = f'{x["exchange_buy"]} → {x["exchange_sell"]}'
book = x.get("book", "—")
if isinstance(book, float):
book = f"{book:.2f}"
print(f'{x["coin"]:<8}{pair:<20}{x["spread_pct"]:>7.2f}'
f'{x["net"]:>9.2f}{book:>11}')
print(f"\nFunding, usia snapshot {f_age:.0f} detik")
for x in fund:
b = x["best"]
legs = (f'{b["exchange_1"]} {b["interval_1"] or "?"} / '
f'{b["exchange_2"]} {b["interval_2"] or "?"}')
print(f'{x["coin"]:<8}{legs:<27}{x["spread_pct"]:>8.4f} %')
print(f"Respons 200: {stats[200]}, 304: {stats[304]}")
Tabel pertama menampilkan koin, pasangan exchange, spread_pct, sisa setelah fee, dan sisa setelah book; tanda hubung berarti book tidak dicek. Tabel kedua menampilkan pasangan exchange terbaik menurut funding, dengan interval funding dan spread_pct. Di atas tabel ada usia snapshot, yaitu waktu sekarang dikurangi meta.updated_at, dan di bawahnya jumlah respons 200 dan 304 sejak mulai.
Riwayat CSV
def save(spot, fund):
"""Menambahkan hasil putaran ke CSV: waktu, dataset, pasangan, spread."""
new = not os.path.exists(CSV_FILE)
ts = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
with open(CSV_FILE, "a", newline="", encoding="utf-8") as f:
w = csv.writer(f)
if new:
w.writerow(["time_utc", "dataset", "coin", "leg_1",
"leg_2", "spread_pct", "net_pct", "book"])
for x in spot:
w.writerow([ts, "spot-spot", x["coin"], x["exchange_buy"],
x["exchange_sell"], x["spread_pct"], x["net"],
x.get("book")]) # None menjadi sel kosong
for x in fund:
b = x["best"]
w.writerow([ts, "funding", x["coin"], b["exchange_1"],
b["exchange_2"], x["spread_pct"], None, None])
Tabel konsol bertahan sampai putaran berikutnya, sedangkan monitor.csv menyimpan setiap putaran: dari sana terlihat berapa lama sebuah pasangan bertahan dan pada jam berapa ia muncul. Modul csv adalah bagian dari pustaka standar Python. Buka file dengan newline="", seperti diwajibkan dokumentasi modul; jika tidak, di sistem yang memakai akhir baris \r\n, tambahan \r akan masuk ke file.
Kolom book berisi sisa setelah book dalam persen, atau status exhausted atau no_book. Modul menulis None sebagai sel kosong, jadi kolom tetap kosong untuk baris funding dan pasangan yang tidak dicek. Waktu dalam UTC.
Loop utama
def main():
usage = get("/account/usage")["data"] # does not use quota
books = usage["plan"] in ("pro", "max")
pace["gap"] = 1.1 / usage["rps_limit"]
print("Paket", usage["plan"], "| snapshot setiap",
usage["freshness_sec"], "detik | order book:",
"ya" if books else "tidak")
pause = usage["freshness_sec"]
while True:
try:
spot, s_meta = spot_rows()
fund, f_meta = funding_rows()
if books:
for x in spot[:BOOK_TOP]:
x["book"] = book_net(x)
show(spot, s_meta, fund, f_meta)
save(spot, fund)
pause = s_meta.get("freshness_sec", pause)
except requests.HTTPError as e:
if e.response.status_code < 500:
raise # kunci, paket, atau parameter: retry tidak akan membantu
print("Error server, mencoba lagi:", e)
except (requests.RequestException, RuntimeError) as e:
print("Tidak ada respons, mencoba lagi:", e)
time.sleep(pause) # lebih cepat dari freshness_sec = snapshot sama
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
print("\nMonitor dihentikan, riwayat ada di", CSV_FILE)
Saat mulai, monitor memanggil /account/usage: request ini tidak memakai kuota dan mengembalikan paket, freshness_sec, dan rps_limit (Penggunaan). Paket memberi tahu monitor apakah order book perlu dicek, dan rps_limit menentukan jeda antar request. Monitor melewati gangguan jaringan dan error 5xx sampai putaran berikutnya, sedangkan error 4xx (kunci salah, langganan kedaluwarsa, paket tanpa endpoint) menghentikannya.
Cara menjalankan dan membaca hasilnya
python3 --version # Wajib Python 3.10 atau lebih baru
python3 -m pip install requests
export GENESIS_API_KEY="gns_live_XXXXXXXXXXXXXXXX"
python3 monitor.py
Hasil di paket Pro, sekadar contoh:
Paket pro | snapshot setiap 10 detik | order book: ya
Spot – Spot, usia snapshot 4 detik
Koin Beli → jual Spread -fee Book
KLM ByBit → Gate 1.62 1.42 0.86
XYZ MEXC → Gate 1.24 1.04 exhausted
ABC BingX → HTX 1.12 0.92 0.31
QRS Gate → OKX 1.05 0.85 —
Funding, usia snapshot 4 detik
XYZ MEXC 4h / Bitget 8h 0.0600 %
ABC Hyper 1h / CoinEx 8h 0.0500 %
Respons 200: 6, 304: 0
KLM: spread barisnya 1,62%, 1,42% setelah dua fee, dan 0,86% setelah order book $1.000 plus fee. XYZ kehabisan book di $1.000: untuk pasangan seperti itu Anda memperkecil ukuran atau melewatinya. QRS ada di baris keempat, jadi book-nya tidak diminta. Tabel funding menunjukkan seberapa sering tiap exchange melakukan settlement: Hyper (nama Hyperliquid di respons) setiap jam dan CoinEx setiap 8 jam. Tekan Ctrl+C untuk menghentikan monitor.
Dari empat pengecekan pasangan di pelajaran 3, monitor menjalankan sendiri selisih harga dan transfer, order book di Pro dan Max, serta menampilkan kesegaran data di atas tabel. Kontrak dan fee penarikan Anda periksa sendiri.
Latihan
Jalankan monitor
Baris pertama hasil menampilkan paket, langkah snapshot, dan apakah book dicek; bandingkan dengan profil Anda.
Geser ambang batas
Setel
MIN_SPREAD = 0.5dan lihat berapa banyak baris baru yang kolom -fee-nya tetap di atas nol.Tambah dataset
Salin
spot_rowsuntuk/arbitrage/futures-futures: format barisnya sama. Buang pengecekan deposit dan penarikan untuk futures, karena di sana tidak ada koin yang dipindahkan antar-exchange.Cek pemakaian
Setelah satu jam, panggil
/account/usagedan bandingkancalls_useddengan perkiraan: di Trial itu maksimal 2 × 60 = 120 panggilan per jam.Cari pasangan yang bertahan
Buka
monitor.csvdi spreadsheet dan hitung berapa putaran berturut-turut tiap pasangan exchange bertahan.
Risiko otomatisasi, dari data basi dan error hingga kunci dan agen AI, dibahas di pelajaran 5, dan polling hemat dengan filter, kompresi, dan ETag di artikel polling API tanpa kena limit.
Tanya jawab
Apa bedanya monitor dengan bot arbitrase?
Monitor mencetak tabel dan menyimpan riwayat; bot mengirim notifikasi tentang pasangan baru dan diam soal pengulangan. Keduanya berbagi kode request dan penyaringan, dan bot Telegram dibahas di Bot arbitrase kripto dengan Python.
Bolehkah polling lebih cepat dari freshness_sec?
Anda tidak akan mendapat data baru: paket Anda menerima snapshot setiap freshness_sec detik. Request tanpa filter sebelum snapshot berikutnya mengembalikan 304 gratis, sedangkan request berfilter memakai satu panggilan untuk data yang sama.
Mengapa kolom Book menampilkan tanda hubung?
Δ order book hanya ada di Pro dan Max, dan monitor memintanya untuk tiga pasangan teratas (BOOK_TOP). Di Trial dan Start, endpoint mengembalikan 403 plan_restricted, jadi monitor tidak memanggilnya.