FXMacroData मैक्रो संकेतों के साथ Binance पर बिटकॉइन की एल्गोरिथम ट्रेडिंग

मैक्रो डेटा बिटकॉइन को क्यों चलाता है

बिटकॉइन एक कंपनी नहीं है। यह कोई लाभांश नहीं देता है, कोई कमाई नहीं रिपोर्ट करता है, और मूल्यांकन को एंकर करने के लिए कोई राजस्व गुणक नहीं है. इसके बजाय, बीटीसी बाजार में सबसे जोखिम-संवेदनशील संपत्ति की तरह व्यापार करता है वैश्विक तरलता की स्थिति, डॉलर की ताकत और वास्तविक ब्याज दर की उम्मीदों पर एक लाभप्रद दांव। इसका मतलब है कि एफएक्स व्यापारियों द्वारा यूआर / यूएसडी या एयूडी / जेपीवाई में स्थिति के लिए उपयोग किए जाने वाले एक ही मैक्रो टूलकिट सीधे बिटकॉक पर लागू होता है।

जब फेड दरों में कटौती करता है, तो डॉलर तरलता का विस्तार होता है और जोखिम संपत्तियों में रैली बीटीसी आमतौर पर आरोप का नेतृत्व करती है। जब सीपीआई आश्चर्यजनक रूप से ऊपर की ओर जाता है, मुद्रास्फीति-हेज कथाएं फिर से उभरती हैं। जब वास्तविक उपज गिरती है, मौद्रिक अवमूल्यन के बारे में कथाएं पूंजी को हार्ड-असट विकल्पों में धकेल देती हैं। इन संकेतों में से प्रत्येक को एफएक्समैक्रोडाटा के संकेतक अंत बिंदुओं के माध्यम से पहले से देखा जा सकता है, जो सेकंड तक टाइमस्टैम्प किया गया है और एक स्वच्छ आरईएसटी एपीआई पर उपलब्ध है।

यह गाइड बिनेंस पर बीटीसी/यूएसडीटी के लिए एक मैक्रो-सिग्नल-संचालित एल्गोरिथम ट्रेडिंग बॉट बनाने के माध्यम से चलता है। अंत तक आपके पास एक पायथन रणनीति होगी जोः

• FXMacroData (नीति दर, मुद्रास्फीति, ब्रेकइवन दर, सोना) से वास्तविक समय के मैक्रो संकेत निकालता है
• उन्हें एक समग्र मैक्रो स्कोर में जोड़ता है
• रिलीज़ कैलेंडर के माध्यम से उच्च प्रभाव वाले रिलीजों के आसपास निष्पादन का कार्यक्रम
• आधिकारिक पायथन एसडीके के माध्यम से बाइनेंस पर बाजार और सीमा आदेश प्रस्तुत करता है

पूर्व शर्तें

शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित तैयार हैंः

• पायथन 3.9+ सभी स्निपेट्स मानक टाइपिंग सिंटैक्स का उपयोग करते हैं
• FXMacroData एपीआई कुंजी पर साइन अप करें /अपना नाम लिखें और डैशबोर्ड से अपनी कुंजी ले लो
• बिनेंस खाता Binance डैशबोर्ड में API कुंजी बनाएं स्पॉट और मार्जिन ट्रेडिंग को सक्षम करें जाँच
• पायथन पैकेज requests, python-binance, pandas, schedule

pip install requests python-binance pandas schedule

अपनी एपीआई कुंजी को हार्ड-कोडिंग के बजाय पर्यावरण चर के रूप में स्टोर करें:

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

चरण 1: FXMacroData से मैक्रो सिग्नल प्राप्त करें

चार मैक्रो श्रृंखलाएँ BTC शासन मॉडल के लिए केंद्रीय हैंः अमरीकी डालर नीतिगत दर, सीपीआई मुद्रास्फीति, को दस साल की ब्रेक बीन मुद्रास्फीति दर, और सोने की स्पॉट कीमतसाथ में वे तरलता के माहौल, मुद्रास्फीति व्यवस्था और हार्ड एसेट्स की ओर भागने की भावना का वर्णन करते हैं।

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

प्रत्येक अंत बिंदु सबसे हाल से सबसे पुराने तक क्रमबद्ध एक सूची लौटाता है data[0] यह हमेशा नवीनतम रीडिंग होती है। valमैक्रो इंडिकेटर के लिए val शीर्षक के आंकड़े रखता है और announcement_datetime दूसरे स्तर के रिलीज टाइमस्टैम्प को शेड्यूल करने के लिए उपयोगी होता है (चरण 4 में शामिल) ।

चरण 2: एक समग्र मैक्रो स्कोर बनाएं

एक एकल संकेतक पर प्रतिक्रिया करने के बजाय, एक समग्र स्कोर सभी चार संकेतों को -1 (पूरी तरह से जोखिम-बंद) और +1 (पूरा जोखिम-ऑन) के बीच एक दिशात्मक संख्या में संश्लेषित करता है। प्रत्येक घटक बिटकॉइन के लिए तेजी या मंदी के आधार पर वजन जोड़ता या घटाता है।

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)

चरण 3: बिनेंस से कनेक्ट करें और BTC मूल्य प्राप्त करें

मैक्रो सिग्नल तैयार होने के साथ, आधिकारिक python-binance ग्राहकः आदेश देने से पहले हमेशा वर्तमान स्पॉट मूल्य प्राप्त करें ताकि पुराने संदर्भ मूल्यों से बचा जा सके।

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

चरण 4: मैक्रो रिलीज़ इवेंट्स के आसपास समयबद्ध करें

एफएक्समैक्रोडाटा की एल्गोरिथम ट्रेडिंग के लिए सबसे शक्तिशाली विशेषताओं में से एक है रिलीज कैलेंडर अंत बिंदु. एक निश्चित टाइमर पर चुनाव संकेतकों के बजाय, आप किसी भी संकेतक के लिए सटीक अनुसूचित रिलीज समय की क्वेरी कर सकते हैं और नए डेटा लैंडिंग के समय अपने तर्क को ठीक से आग लगा सकते हैं।

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

सटीक रिलीज टाइमस्टैम्प के साथ, आप रिलीज के बाद सिग्नल रिफ्रेश को शेड्यूल कर सकते हैं जिससे बाजार को री-स्कोरिंग और री-ट्रेडिंग से पहले कुछ मिनट के लिए प्रिंट को अवशोषित करने की अनुमति मिलती हैः

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)

चरण 5: आकार की स्थिति और आदेश प्रस्तुत करें

स्थिति आकार जहां अधिकांश एल्गोरिथम रणनीतियों में पैसा खोना है संकेत तर्क में नहीं। नीचे दिया गया फ़ंक्शन उपलब्ध पूंजी के एक अंश के रूप में बीटीसी व्यापार का आकार देता है, मैक्रो स्कोर के पूर्ण परिमाण के साथ स्केल करता है। उच्च-अभिव्यक्ति मैक्रो वातावरण (शून्य से आगे स्कोर) एक बड़े आवंटन को उचित ठहराता है, लेकिन कभी भी एक विन्यास योग्य अधिकतम से अधिक नहीं।

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

चरण 6: पूरी रणनीति लूप को इकट्ठा करें

अब प्रत्येक टुकड़े को एक में मिलाएं। run_strategy() एक कार्य जो ताजा मैक्रो डेटा प्राप्त करता है, स्कोर की गणना करता है और एक व्यवस्था परिवर्तन की जांच करता है तथा इसके अनुसार बीटीसी की स्थिति खोलता या बंद करता है।

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)

चरण 7: जोखिम प्रबंधन और परिचालन विचार

मैक्रो सिग्नल रणनीति में शुद्ध तकनीकी प्रणाली की तुलना में बहुत कम ट्रेडिंग आवृत्ति होती है प्रविष्टियां और निकास आमतौर पर प्रति वर्ष 68 प्रमुख संकेतक रिलीज़ के आसपास होते हैं। यह कम आवृत्ती एक विशेषता है, बग नहींः आप कई सप्ताह के शासन परिवर्तन के लिए स्थिति बना रहे हैं, इंट्राडे शोर नहीं। हालांकि, इसका मतलब यह भी है कि प्रत्येक स्थिति प्रति व्यापार अधिक जोखिम लेती है, जिससे अनुशासित जोखिम प्रबंधन गैर-वार्तालाप योग्य हो जाता है।

एक अतिरिक्त विचारः बीटीसी व्यापार 24/7 लेकिन मैक्रो घटनाओं निर्धारित कर रहे हैं. एफओएमसी, सीपीआई, और एनएफपी रिलीज सभी अमेरिकी बाजार के घंटों के दौरान होता है. अपने शेड्यूलर समय क्षेत्र के बारे में जागरूक होना चाहिए पूरे यूटीसी का उपयोग करें और केवल अंतिम उपयोगकर्ताओं को प्रदर्शित करते समय परिवर्तित करें. FXMacroData के announcement_datetime क्षेत्र हमेशा UTC है, यह सीधा बना रहा है।

रणनीति का विस्तार

यह ढांचा जानबूझकर मॉड्यूलर है। यहाँ अगले का पता लगाने के लिए प्राकृतिक विस्तार हैंः

• सीओटी पोजिशनिंग डेटा जोड़ें FXMacroData का CFTC COT एंडपॉइंट USD वायदा में साप्ताहिक सट्टा स्थिति प्रदान करता है। अत्यधिक लघु USD स्थिति ऐतिहासिक रूप से BTC की पूंछ की हवा है। इसे खींचें /cot/usd और मैक्रो स्कोर में एक नेट पोजिशनिंग टर्म जोड़ें।
• बहु मुद्रा स्कोर वैश्विक तरलता स्कोर बनाने के लिए EUR, JPY और GBP मैक्रो संकेतों को शामिल करें। जब कई G10 केंद्रीय बैंक एक साथ ढील मोड में होते हैं, तो BTC जोखिम-परिस्थिति सबसे मजबूत होती है।
• ब्रेक-प्विन ट्रेंड वेग ब्रेक एवेंस मुद्रास्फीति के स्तर के बजाय 4 सप्ताह की दर का उपयोग करें। ब्रेक एवें में तेज वृद्धि अकेले स्तर की तुलना में अधिक समय पर प्रारंभिक संकेत है।
• रिलीज़ कैलेंडर एकीकरण प्रश्न पूछें रिलीज कैलेंडर सभी USD घटनाओं के लिए एक महीने के लिए, उन्हें प्रभाव भार द्वारा समूहित करें, और उन खिड़कियों की पहचान करें जहां कई उच्च प्रभाव वाले रिलीज 48 घंटों के भीतर समूहित होते हैं ये अवधि हैं जिनके लिए स्थिति बनाने लायक हैं।

सारांश

आपके पास अब एक कार्यशील मैक्रो-सिग्नल-संचालित बिटकॉइन ट्रेडिंग बॉट है जो FXMacroData संकेतक डेटा को सीधे बाइनेंस निष्पादन से जोड़ता है। रणनीति एक समग्र मैक्रो स्कोर बनाने के लिए USD नीति दर, सीपीआई, ब्रेकवीन मुद्रास्फीति और सोने को पढ़ती है, वास्तविक दुनिया की घोषणा की घटनाओं के आसपास खुद को शेड्यूल करती है, और आकार और बीटीसी / यूएसडीटी आदेशों को शासन के विश्वास के अनुपात में प्रस्तुत करती है।

इस श्रृंखला में अगला लेख इस ढांचे को ऐतिहासिक डेटा के खिलाफ बैकटेस्टिंग और वास्तविक FXMacroData समय-श्रृंखला का उपयोग करके स्कोर भार को कैलिब्रेट करने से संबंधित है जो 2015 तक वापस जाता है।