Algo-Trading Bitcoin di Binance dengan Sinyal Makro FXMacroData

Mengapa Makro Data Menggerak Bitcoin

Bitcoin bukanlah sebuah perusahaan. Bitcoin tidak membayar dividen, tidak melaporkan laba, dan tidak memiliki kelipatan pendapatan untuk menanamkan penilaian. Sebaliknya, BTC diperdagangkan seperti aset paling sensitif terhadap risiko di pasar taruhan leveraged pada kondisi likuiditas global, kekuatan dolar, dan harapan suku bunga riil. Itu berarti toolkit makro yang sama yang digunakan oleh pedagang FX untuk memposisikan EUR/USD atau AUD/JPY berlaku langsung untuk Bitcoin.

Ketika Fed memangkas suku bunga, likuiditas dolar berkembang dan aset risiko rally BTC biasanya memimpin biaya. Ketika CPI mengejutkan ke atas, narasi lindung nilai inflasi muncul kembali. Ketika hasil riil runtuh, naratif tentang penurunan nilai mata uang mendorong modal ke alternatif aset keras. Setiap sinyal ini dapat diamati sebelumnya melalui titik akhir indikator FXMacroData, bertanda waktu hingga detik dan tersedia melalui API REST yang bersih.

Panduan ini berjalan melalui membangun robot perdagangan algoritmik yang didorong oleh sinyal makro untuk BTC / USDT di Binance.

• Mendapatkan sinyal makro real-time dari FXMacroData (tingkat kebijakan, inflasi, tingkat impas, emas)
• Menggabungkan mereka ke dalam skor makro komposit
• Jadwal pelaksanaan sekitar rilis berdampak tinggi melalui kalender rilis
• Mengirim pesanan pasar dan batas pada Binance melalui Python SDK resmi

Persyaratan

Sebelum memulai, pastikan Anda siapkan:

• Python 3.9+ semua cuplikan menggunakan sintaksis penulisan standar
• Kunci API FXMacroData daftar di /langganan dan ambil kunci dari dasbor
• Akun Binance dengan saldo USDT yang terfund membuat kunci API di dasbor Binance dengan Membuat Trading Spot & Margin diperiksa
• Paket PythonAku tidak tahu. requestsAku akan pergi. python-binanceAku akan pergi. pandasAku akan pergi. schedule

pip install requests python-binance pandas schedule

Simpan kunci API Anda sebagai variabel lingkungan daripada mengkode keras mereka:

export FXMACRO_API_KEY="YOUR_FXMACRODATA_KEY"
export BINANCE_API_KEY="YOUR_BINANCE_KEY"
export BINANCE_SECRET_KEY="YOUR_BINANCE_SECRET"

Langkah 1: Mengambil Sinyal Makro dari FXMacroData

Empat rangkaian makro adalah pusat dari model rezim BTC: Nilai tukar mata uangAku akan pergi. Inflasi IPK, yang Tingkat inflasi titik impas 10 tahun, dan harga spot emasBersama-sama mereka menggambarkan lingkungan likuiditas, rezim inflasi, dan sentimen penerbangan ke aset keras.

import os
import requests

BASE_URL = "https://fxmacrodata.com/api/v1"
FXMACRO_KEY = os.environ["FXMACRO_API_KEY"]


def get_series(path: str, start: str = "2024-01-01") -> list[dict]:
    """Fetch a time-series from FXMacroData."""
    resp = requests.get(
        f"{BASE_URL}{path}",
        params={"api_key": FXMACRO_KEY, "start": start},
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json()["data"]


# Macro inputs
policy_rate   = get_series("/announcements/usd/policy_rate")
cpi           = get_series("/announcements/usd/inflation")
breakeven_10y = get_series("/announcements/usd/breakeven_inflation_rate")
gold          = get_series("/commodities/gold")

# Each item: {"date": "2025-04-08", "val": 5.25, "announcement_datetime": "..."}
print(f"Policy rate (latest): {policy_rate[0]['val']}%")
print(f"CPI (latest):          {cpi[0]['val']}%")
print(f"10Y breakeven:         {breakeven_10y[0]['val']}%")
print(f"Gold spot:             ${gold[0]['val']:.2f}")

Setiap titik akhir mengembalikan daftar yang diurutkan dari yang terbaru ke yang tertua data[0] adalah selalu pembacaan terbaru. valUntuk indikator makro, val memegang tokoh judul dan announcement_datetime membawa timestamp rilis tingkat dua yang berguna untuk penjadwalan (dicakup dalam Langkah 4).

Langkah 2: Buat Skor Makro Komposit

Alih-alih bereaksi terhadap satu indikator, skor komposit mensintesis semua empat sinyal menjadi satu angka arah antara -1 (penuh risiko-off) dan +1 (penuhnya risiko-on).

def macro_score(
    policy_rate_pct: float,
    cpi_pct: float,
    breakeven_pct: float,
    gold_usd: float,
    *,
    gold_baseline: float = 1900.0,
) -> float:
    """
    Returns a composite macro score in [-1, +1].

    Positive = risk-on / BTC bullish environment.
    Negative = risk-off / BTC bearish environment.
    """
    score = 0.0

    # ── Policy rate regime (weight 0.35) ──────────────────────────
    # Sub-4.5% = accommodative → bullish; above 5.5% = restrictive → bearish
    if policy_rate_pct < 4.5:
        score += 0.35
    elif policy_rate_pct <= 5.5:
        score += 0.35 * (5.5 - policy_rate_pct) / 1.0
    else:
        score -= 0.20

    # ── Inflation regime (weight 0.25) ────────────────────────────
    # CPI 2–4%: moderate inflation → neutral/slightly bullish
    # CPI > 6%: high inflation → monetary debasement narrative → bullish
    # CPI < 1.5%: deflationary risk → bearish
    if cpi_pct > 6.0:
        score += 0.25
    elif cpi_pct >= 2.0:
        score += 0.10
    else:
        score -= 0.15

    # ── Breakeven inflation (weight 0.20) ─────────────────────────
    # Rising breakevens signal inflation expectations are re-anchoring → bullish
    if breakeven_pct >= 2.5:
        score += 0.20
    elif breakeven_pct >= 2.0:
        score += 0.10
    else:
        score -= 0.10

    # ── Gold trend (weight 0.20) ──────────────────────────────────
    # Gold above baseline confirms hard-asset demand → bullish
    gold_ratio = (gold_usd - gold_baseline) / gold_baseline
    score += 0.20 * max(-1.0, min(1.0, gold_ratio * 5))

    return round(max(-1.0, min(1.0, score)), 4)


score = macro_score(
    policy_rate_pct=policy_rate[0]["val"],
    cpi_pct=cpi[0]["val"],
    breakeven_pct=breakeven_10y[0]["val"],
    gold_usd=gold[0]["val"],
)
print(f"Composite macro score: {score:+.4f}")
# e.g. → +0.6500  (bullish regime)

Langkah 3: Hubungkan ke Binance dan Dapatkan Harga BTC

Dengan sinyal makro siap, terhubung ke Binance menggunakan resmi python-binance Selalu ambil harga spot saat ini sebelum menempatkan pesanan untuk menghindari nilai referensi usang.

import os
from binance.client import Client

BINANCE_KEY    = os.environ["BINANCE_API_KEY"]
BINANCE_SECRET = os.environ["BINANCE_SECRET_KEY"]

client = Client(BINANCE_KEY, BINANCE_SECRET)

# Verify connectivity
status = client.get_system_status()
print(f"Binance status: {status['msg']}")  # → "normal"

# Latest BTC/USDT price
ticker = client.get_symbol_ticker(symbol="BTCUSDT")
btc_price = float(ticker["price"])
print(f"BTC/USDT spot: ${btc_price:,.2f}")

# Current USDT balance
account = client.get_account()
usdt_balance = next(
    (float(b["free"]) for b in account["balances"] if b["asset"] == "USDT"),
    0.0,
)
print(f"Available USDT: ${usdt_balance:,.2f}")

Langkah 4: Jadwalkan sekitar Macro Release Event

Salah satu fitur FXMacroData yang paling kuat untuk perdagangan algoritmik adalah Tanggal akhir rilisAlih-alih jajak pendapat indikator pada timer tetap, Anda dapat pertanyaan waktu rilis yang tepat dijadwalkan untuk indikator apapun dan menembakkan logika Anda tepat ketika data baru tanah.

import datetime
import schedule
import time


def get_next_release(currency: str, indicator: str) -> datetime.datetime | None:
    """
    Returns the next scheduled release datetime for an indicator.
    The calendar endpoint returns upcoming release dates ordered ascending.
    """
    resp = requests.get(
        f"{BASE_URL}/calendar/{currency}",
        params={"api_key": FXMACRO_KEY},
        timeout=10,
    )
    resp.raise_for_status()
    events = resp.json().get("data", [])

    now_utc = datetime.datetime.now(tz=datetime.timezone.utc)
    for event in events:
        if event.get("indicator") != indicator:
            continue
        release_str = event.get("release_datetime") or event.get("date")
        if not release_str:
            continue
        release_dt = datetime.datetime.fromisoformat(release_str.replace("Z", "+00:00"))
        if release_dt > now_utc:
            return release_dt
    return None


# Find when the next FOMC policy rate decision is scheduled
next_fomc = get_next_release("usd", "policy_rate")
if next_fomc:
    delta = next_fomc - datetime.datetime.now(tz=datetime.timezone.utc)
    print(f"Next FOMC release: {next_fomc.isoformat()} ({delta.days}d {delta.seconds // 3600}h away)")
else:
    print("No upcoming policy_rate event found in calendar.")


# Find when the next CPI release is scheduled
next_cpi = get_next_release("usd", "inflation")
if next_cpi:
    print(f"Next CPI release:  {next_cpi.isoformat()}")

Dengan timestamp rilis yang tepat, Anda dapat menjadwalkan pembaruan sinyal pasca rilis yang memungkinkan pasar untuk menyerap cetakan selama beberapa menit sebelum mencetak ulang dan memperdagangkan kembali:

def on_macro_release():
    """Called shortly after a scheduled macro release."""
    print("Macro release fired — refreshing signals...")
    run_strategy()


def schedule_next_release(currency: str, indicator: str, delay_seconds: int = 90):
    """
    Schedules the strategy to run 'delay_seconds' after the next release.
    A 90-second delay lets the initial market reaction settle slightly.
    """
    release_dt = get_next_release(currency, indicator)
    if not release_dt:
        return

    fire_at = release_dt + datetime.timedelta(seconds=delay_seconds)
    fire_str = fire_at.strftime("%H:%M:%S")  # schedule library uses HH:MM:SS
    schedule.every().day.at(fire_str).do(on_macro_release).tag(f"{currency}_{indicator}")
    print(f"Scheduled signal refresh at {fire_str} UTC after {currency.upper()} {indicator}")


schedule_next_release("usd", "policy_rate", delay_seconds=90)
schedule_next_release("usd", "inflation", delay_seconds=60)

Langkah 5: Ukuran Posisi dan Kirim Pesan

Posisi ukuran adalah di mana sebagian besar strategi algoritmik kehilangan uang tidak dalam logika sinyal. Fungsi di bawah ukuran perdagangan BTC sebagai sebagian dari modal yang tersedia, skala dengan besar mutlak skor makro. lingkungan makro keyakinan yang lebih tinggi (skor lebih jauh dari nol) membenarkan alokasi yang lebih besar, tetapi tidak pernah lebih dari maksimum yang dapat dikonfigurasi.

from binance.enums import SIDE_BUY, SIDE_SELL, ORDER_TYPE_MARKET, ORDER_TYPE_LIMIT
from binance.exceptions import BinanceAPIException
import math


def compute_quantity(
    score: float,
    usdt_balance: float,
    btc_price: float,
    max_position_pct: float = 0.20,
) -> float:
    """
    Scale position size between 0 and max_position_pct of USDT balance.
    Only trade when |score| > 0.30 to avoid noise-driven entries.
    Returns BTC quantity rounded to Binance's minimum lot size (0.00001 BTC).
    """
    if abs(score) < 0.30:
        return 0.0

    conviction = (abs(score) - 0.30) / 0.70          # 0.0 → 1.0
    usdt_to_trade = usdt_balance * max_position_pct * conviction
    btc_qty = usdt_to_trade / btc_price
    return math.floor(btc_qty * 100_000) / 100_000    # 5 decimal places


def place_order(side: str, quantity: float, btc_price: float) -> dict | None:
    """
    Submit a market order. For limit orders, pass a price to get_order_book
    and sit 0.1% inside the spread.
    """
    if quantity <= 0.0:
        print("Quantity zero — no order placed.")
        return None

    try:
        order = client.order_market(
            symbol="BTCUSDT",
            side=side,
            quantity=quantity,
        )
        print(f"Order placed: {side} {quantity:.5f} BTC @ ~${btc_price:,.2f}")
        return order
    except BinanceAPIException as exc:
        print(f"Binance order error: {exc.message}")
        return None

Langkah 6: Mengumpulkan seluruh lingkaran strategi

Sekarang gabungkan setiap bagian menjadi satu run_strategy() fungsi yang mengambil data makro baru, menghitung skor, memeriksa perubahan regime, dan membuka atau menutup posisi BTC sesuai.

import json
import pathlib

STATE_FILE = pathlib.Path("strategy_state.json")


def load_state() -> dict:
    if STATE_FILE.exists():
        return json.loads(STATE_FILE.read_text())
    return {"position": 0.0, "last_score": 0.0}


def save_state(state: dict) -> None:
    STATE_FILE.write_text(json.dumps(state, indent=2))


def run_strategy() -> None:
    state = load_state()

    # ── 1. Fetch fresh macro data ──────────────────────────────────
    policy_rate_val   = get_series("/announcements/usd/policy_rate")[0]["val"]
    cpi_val           = get_series("/announcements/usd/inflation")[0]["val"]
    breakeven_val     = get_series("/announcements/usd/breakeven_inflation_rate")[0]["val"]
    gold_val          = get_series("/commodities/gold")[0]["val"]

    # ── 2. Compute macro score ─────────────────────────────────────
    score = macro_score(policy_rate_val, cpi_val, breakeven_val, gold_val)
    print(f"Macro score: {score:+.4f}  (prev: {state['last_score']:+.4f})")

    # ── 3. Fetch current Binance position and price ───────────────
    account   = client.get_account()
    btc_held  = float(next(b["free"] for b in account["balances"] if b["asset"] == "BTC"))
    usdt_held = float(next(b["free"] for b in account["balances"] if b["asset"] == "USDT"))
    btc_price = float(client.get_symbol_ticker(symbol="BTCUSDT")["price"])

    # ── 4. Regime change logic ─────────────────────────────────────
    prev_score    = state["last_score"]
    was_long      = prev_score >= 0.30
    is_long_now   = score >= 0.30
    was_flat      = abs(prev_score) < 0.30
    is_flat_now   = abs(score) < 0.30

    if is_long_now and (was_flat or prev_score < 0):
        # Enter or increase long
        qty = compute_quantity(score, usdt_held, btc_price)
        place_order(SIDE_BUY, qty, btc_price)

    elif is_flat_now and was_long and btc_held > 0.0001:
        # Exit long — macro regime has turned neutral
        exit_qty = math.floor(btc_held * 100_000) / 100_000
        place_order(SIDE_SELL, exit_qty, btc_price)

    elif score < -0.30 and btc_held > 0.0001:
        # Hard exit on bearish signal
        exit_qty = math.floor(btc_held * 100_000) / 100_000
        place_order(SIDE_SELL, exit_qty, btc_price)
        print("BEARISH regime — full exit.")

    # ── 5. Persist state ───────────────────────────────────────────
    state["last_score"] = score
    save_state(state)


# ── Run once immediately, then on each scheduled release ──────────────
run_strategy()

# Keep scheduler alive
while True:
    schedule.run_pending()
    time.sleep(10)

Langkah 7: Manajemen Risiko dan Pertimbangan Operasional

A macro signal strategy has a much lower trading frequency than a pure technical system — entries and exits typically occur around 6–8 major indicator releases per year. That low frequency is a feature, not a bug: you are positioning for multi-week regime changes, not intraday noise. However, it also means each position carries more risk per trade, making disciplined risk management non-negotiable.

Satu pertimbangan tambahan: BTC diperdagangkan 24/7 tetapi acara makro dijadwalkan. FOMC, CPI, dan NFP rilis semua terjadi selama jam pasar AS. Penjadwal Anda harus timezone-aware menggunakan UTC sepanjang dan mengkonversi hanya ketika menampilkan pengguna akhir. announcement_datetime lapangan selalu UTC, membuat ini mudah.

Memperluas Strategi

Kerangka kerja ini sengaja modular. Berikut adalah ekstensi alami untuk dijelajahi selanjutnya:

• Tambahkan data posisi COT Endpoint CFTC COT FXMacroData menyediakan posisi spekulatif mingguan dalam USD futures. Posisi USD pendek ekstrim secara historis adalah angin belakang BTC. Tarik dengan /cot/usd dan tambahkan istilah posisi bersih ke skor makro.
• Skor multi-mata uang — incorporate EUR, JPY, and GBP macro signals to construct a global liquidity score. When multiple G10 central banks are in easing mode simultaneously, BTC risk-on conditions are strongest.
• Kecepatan tren penyeimbangan daripada tingkat inflasi titik impas, gunakan tingkat perubahan 4 minggu.
• Integrasi Kalender Rilis pertanyaan Kalender rilis untuk semua peristiwa USD satu bulan keluar, mengelompokkannya berdasarkan berat dampak, dan mengidentifikasi jendela di mana beberapa pelepasan dampak tinggi berkelompok dalam 48 jam itulah periode yang layak untuk posisi.

Ringkasan

Anda sekarang memiliki robot perdagangan Bitcoin yang didorong oleh sinyal makro yang berfungsi yang menghubungkan data indikator FXMacroData langsung ke eksekusi Binance. Strategi membaca tingkat kebijakan USD, CPI, inflasi impas, dan emas untuk membangun skor makro komposit, menjadwalkan dirinya di sekitar acara pengumuman dunia nyata, dan ukuran dan mengirimkan pesanan BTC/USDT secara proporsional dengan keyakinan rezim.

Artikel berikutnya dalam seri ini mencakup backtesting kerangka kerja ini terhadap data historis dan kalibrasi nilai bobot menggunakan real FXMacroData time-series kembali ke 2015.