FXMacroData मैक्रो सिग्नल के साथ कॉइनबेस पर अल्गो-ट्रेडिंग बिटकॉइन

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

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

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

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

• FXMacroData से USD नीति दर, मुद्रास्फीति, ब्रेक एवेंज मुद्रास्फ़ीति और सोने के आंकड़े निकालता है
• उन्हें एक समग्र मैक्रो-रेजिम स्कोर में जोड़ता है
• FXMacroData रिलीज़ कैलेंडर के माध्यम से उच्च प्रभाव वाले मैक्रो रिलीजों के आसपास निष्पादन का समयबद्ध करें
• आधिकारिक का उपयोग करके Coinbase पर BTC-USD बाजार आदेश भेजता है coinbase-advanced-py एसडीके

पूर्व शर्तें

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

• पायथन 3.10+ सभी स्निपेट्स आधुनिक टाइपिंग सिंटैक्स का उपयोग करते हैं
• FXMacroData एपीआई कुंजी पर साइन अप करें /अपना नाम लिखें और खाता डैशबोर्ड से अपनी कुंजी ले लो
• कॉइनबेस उन्नत व्यापार खाता एक क्लाउड एपीआई ट्रेडिंग कुंजी (एपीआई कुंजी नाम + ईसी निजी कुंजी) में डेवलपर प्लेटफार्म कंसोल के साथ व्यापार अनुमतिएँ सक्षम
• पायथन पैकेज requests, coinbase-advanced-py, pandas, schedule

pip install requests coinbase-advanced-py pandas schedule

अपने क्रेडेंशियल्स को पर्यावरण चर के रूप में स्टोर करें स्रोत फ़ाइलों में हार्ड-कोड रहस्य कभी नहींः

export FXMACRO_API_KEY="YOUR_FXMACRODATA_KEY"
export COINBASE_API_KEY_NAME="organizations/ORG_ID/apiKeys/KEY_ID"
export COINBASE_PRIVATE_KEY="-----BEGIN EC PRIVATE KEY-----
MHQCAQEEIBs...
-----END EC PRIVATE KEY-----"

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

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

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

# data[0] is always the most recent reading
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}")

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

चरण 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) ──────────────────────────────
    # Below 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) ────────────────────────────────
    # 2–4% moderate inflation → neutral/slightly bullish
    # >6% high inflation → debasement narrative → bullish
    # <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 re-anchoring inflation expectations → 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.6000  (bullish regime)

Step 3: Connect to the Coinbase Advanced Trade API

अधिकारी coinbase-advanced-py पुस्तकालय Coinbase के REST एपीआई को लपेटता है और स्वचालित रूप से JWT प्रमाणीकरण को संभालता है. RESTClient अपने क्लाउड एपीआई ट्रेडिंग कुंजी नाम और संबंधित ईसी निजी कुंजी का उपयोग करके।

import os
import uuid
from coinbase.rest import RESTClient

CB_KEY_NAME    = os.environ["COINBASE_API_KEY_NAME"]
CB_PRIVATE_KEY = os.environ["COINBASE_PRIVATE_KEY"]

client = RESTClient(api_key=CB_KEY_NAME, api_secret=CB_PRIVATE_KEY)

# Verify connectivity and fetch current BTC-USD price
product = client.get_best_bid_ask(product_ids=["BTC-USD"])
bids = product["pricebooks"][0]["bids"]
asks = product["pricebooks"][0]["asks"]
btc_price = (float(bids[0]["price"]) + float(asks[0]["price"])) / 2
print(f"BTC-USD mid-price: ${btc_price:,.2f}")

# Available USD balance
accounts = client.get_accounts()
usd_balance = 0.0
btc_balance = 0.0
for acct in accounts["accounts"]:
    if acct["currency"] == "USD":
        usd_balance = float(acct["available_balance"]["value"])
    if acct["currency"] == "BTC":
        btc_balance = float(acct["available_balance"]["value"])

print(f"Available USD: ${usd_balance:,.2f}")
print(f"Available BTC: {btc_balance:.6f}")

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

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

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 events in ascending date order.
    """
    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


# Example: find the next FOMC policy rate decision
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: {next_fomc.isoformat()}  ({delta.days}d {delta.seconds // 3600}h away)")

# Example: find the next CPI print
next_cpi = get_next_release("usd", "inflation")
if next_cpi:
    print(f"Next CPI:  {next_cpi.isoformat()}")

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

def on_macro_release():
    """Called shortly after a scheduled macro release fires."""
    print("Macro release detected — 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 absorb before entry.
    """
    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.every().day.at(fire_str).do(on_macro_release).tag(
        f"{currency}_{indicator}"
    )
    print(f"Scheduled 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: आकार की स्थिति और कॉइनबेस पर आदेश भेजें

Coinbase उन्नत व्यापार आदेश बिनेंस से अलग काम करते हैंः खरीदना आदेश निर्दिष्ट करें quote_size (USD राशि खर्च करने के लिए), जबकि बेचना आदेश निर्दिष्ट करें base_size (बिक्री के लिए बीटीसी राशि) नीचे दिया गया आकार फ़ंक्शन मैक्रो स्कोर की पूर्ण परिमाण के साथ USD आवंटन को स्केल करता है उच्च आश्वासन एक बड़े आवंटन का औचित्य देता है, जो एक कॉन्फ़िगर करने योग्य अधिकतम पर सीमित है।

import math


def compute_usd_allocation(
    score: float,
    usd_balance: float,
    max_position_pct: float = 0.20,
    min_threshold: float = 0.30,
) -> float:
    """
    Returns the USD amount to deploy for a BUY order.
    Scales between 0 and max_position_pct of available USD balance.
    Returns 0.0 if |score| < min_threshold (noise-filtered).
    Minimum order size on Coinbase Advanced Trade is $1 USD.
    """
    if abs(score) < min_threshold:
        return 0.0
    conviction = (abs(score) - min_threshold) / (1.0 - min_threshold)
    usd_to_trade = usd_balance * max_position_pct * conviction
    return max(1.0, round(usd_to_trade, 2))


def place_buy(usd_amount: float) -> dict | None:
    """Submit a market BUY order for a given USD amount."""
    if usd_amount <= 0:
        print("USD amount zero — no buy order placed.")
        return None
    order_id = str(uuid.uuid4())
    try:
        result = client.market_order_buy(
            client_order_id=order_id,
            product_id="BTC-USD",
            quote_size=str(usd_amount),
        )
        print(f"BUY order submitted: ${usd_amount:.2f} USD  (order_id={order_id})")
        return result
    except Exception as exc:
        print(f"Coinbase buy error: {exc}")
        return None


def place_sell(btc_amount: float) -> dict | None:
    """Submit a market SELL order for a given BTC amount."""
    # Minimum BTC lot size on Coinbase Advanced Trade is 0.000001 BTC
    btc_amount = math.floor(btc_amount * 1_000_000) / 1_000_000
    if btc_amount <= 0:
        print("BTC amount zero — no sell order placed.")
        return None
    order_id = str(uuid.uuid4())
    try:
        result = client.market_order_sell(
            client_order_id=order_id,
            product_id="BTC-USD",
            base_size=str(btc_amount),
        )
        print(f"SELL order submitted: {btc_amount:.6f} BTC  (order_id={order_id})")
        return result
    except Exception as exc:
        print(f"Coinbase sell error: {exc}")
        return None

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

अब सभी टुकड़ों को एक साथ लाओ। run_strategy() प्रत्येक कॉल पर यह ताजा मैक्रो डेटा प्राप्त करता है, स्कोर को पुनः गणना करता है और एक शासन परिवर्तन का पता लगाता है, और इसके अनुसार प्रवेश करता है या बाहर निकलता है। राज्य को एक JSON फ़ाइल में बनाए रखा जाता है ताकि प्रक्रिया स्थिति ट्रैकिंग खोए बिना पुनः आरंभ हो सके।

import json
import pathlib

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


def load_state() -> dict:
    if STATE_FILE.exists():
        return json.loads(STATE_FILE.read_text())
    return {"position_btc": 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. Refresh 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)
    prev  = state["last_score"]
    print(f"Macro score: {score:+.4f}  (prev: {prev:+.4f})")

    # ── 3. Fetch current Coinbase balances ─────────────────────────────
    accounts  = client.get_accounts()
    usd_avail = 0.0
    btc_avail = 0.0
    for acct in accounts["accounts"]:
        if acct["currency"] == "USD":
            usd_avail = float(acct["available_balance"]["value"])
        if acct["currency"] == "BTC":
            btc_avail = float(acct["available_balance"]["value"])

    # ── 4. Regime change logic ─────────────────────────────────────────
    is_bullish = score >= 0.30
    was_bullish = prev >= 0.30
    is_neutral  = abs(score) < 0.30
    is_bearish  = score < -0.30

    if is_bullish and not was_bullish:
        # New bullish regime — enter long via USD allocation
        usd_to_use = compute_usd_allocation(score, usd_avail)
        place_buy(usd_to_use)

    elif is_neutral and was_bullish and btc_avail > 0.000001:
        # Regime turned neutral — exit position
        place_sell(btc_avail)
        print("Regime neutral — exiting BTC position.")

    elif is_bearish and btc_avail > 0.000001:
        # Hard exit on bearish macro signal
        place_sell(btc_avail)
        print("BEARISH regime — full exit.")

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


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

while True:
    schedule.run_pending()
    time.sleep(10)

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

A macro-signal strategy trades infrequently — regime changes driven by FOMC, CPI, and NFP prints typically produce 6–10 actionable signals per year. That low frequency is by design: you are positioning for multi-week directional moves, not intraday noise. But each position carries meaningful risk, so disciplined controls are essential.

FXMacroData से सभी समय टिकट सहित announcement_datetime कैलेंडर के अंत बिंदु से संकेतकों की प्रतिक्रियाओं और रिलीज़ की तारीखों में UTC हैं। अपने शेड्यूलिंग लॉजिक को पूरे समय UTC में रखें और केवल प्रदर्शन उद्देश्यों के लिए परिवर्तित करें। यह अमेरिकी डेटा रिलीजों के आसपास दिन के समय की अस्पष्टता को समाप्त करता है, जो शेड्यूलर बग का एक सामान्य स्रोत है।

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

यह ढांचा मॉड्यूलर है। इसके बाद कई प्राकृतिक विस्तारों का पता लगाने लायक हैः

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

सारांश

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

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