क्यों EUR/USD मैक्रो विचलन क्रैकन पर क्रिप्टो ड्राइव करता है
क्रैकन क्रिप्टो एक्सचेंज परिदृश्य में एक अलग स्थिति रखता हैः इसका उपयोग यूरोपीय व्यापारियों द्वारा किया जाता है, सीधे यूरो जमा स्वीकार करता है, और यूरो के साथ-साथ यूएसडी के खिलाफ कई जोड़े उद्धृत करता है। इसका मतलब है कि यूआर / यूएसडी को नियंत्रित करने वाले मैक्रो बल ईसीबी बनाम फेड नीति विचलन, यूरो क्षेत्र बनाम यूएस मुद्रास्फीति अंतर, और वास्तविक उपज स्प्रेड दिशात्मक टेलविंड्स और हेडविंडस बनाते हैं जो स्पष्ट रूप से क्रैकने सूचीबद्ध जोड़े जैसे एक्सबीटी / यूएसएस और एक्सबीਟੀ / यूरो में दिखाई देते हैं।
जब फेड सख्त होता है जबकि ईसीबी पकड़ता है, डॉलर मजबूत होता है, वास्तविक उपज बढ़ जाती है, और जोखिम वाली संपत्ति (क्रिप्टो सहित) आमतौर पर बिक्री के दबाव का सामना करती है। जब ईसीपी और फेड विपरीत दिशा में असंगत होते हैं ईसीई एक फेड विराम में बढ़ जाती हैं, उदाहरण के लिए यूरो की ताकत और संपीड़ित अमेरिकी वास्तविक उपजा BTC में जोखिम-पर स्थिति का समर्थन करती है. ये शासन सप्ताह और महीनों तक चलते हैं, और वे FXMacroData के संकेतक अंत बिंदुओं के माध्यम से अग्रिम में पूरी तरह से अवलोकन योग्य हैं।
यह गाइड क्रैकन पर XBT/USD के लिए एक मैक्रो-सिग्नल-संचालित एल्गोरिथम ट्रेडिंग बॉट के निर्माण के माध्यम से चलता है। अंत तक आपके पास एक कामकाजी पायथन रणनीति होगी जोः
- FXMacroData से EUR और USD मैक्रो सिग्नल निकालता है (नीति दर, CPI, मूल मुद्रास्फीति और EUR/USD स्पॉट)
- मैक्रो व्यवस्था को वर्गीकृत करने के लिए EUR/USD विचलन स्कोर की गणना करता है
- FXMacroData जारी करने के कैलेंडर के माध्यम से ECB और Fed जारी करने की तारीखों के आसपास निष्पादन विंडो को शेड्यूल करता है
- आधिकारिक REST API के माध्यम से Kraken पर बाजार और सीमा आदेश प्रस्तुत करता है
- सरल स्थिति आकार और जोखिम नियंत्रण लागू करता है
मूल थीसिस
ईसीबी/फेड नीति विचलन डॉलर में कई सप्ताह की दिशागत प्रवृत्तियों का निर्माण करता है। क्योंकि बीटीसी मुख्य रूप से USD में मूल्यवान है और वैश्विक प्रतिभागियों द्वारा कारोबार किया जाता है जो EUR के संपर्क में भी हैं, सत्र खोलने से पहले EUR/USD मैक्रो विचलन को पढ़ना आपको इस कदम पर प्रतिक्रिया देने के बजाय शासन के साथ स्थिति बनाने की अनुमति देता है।
पूर्व शर्तें
शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित तैयार हैंः
- पायथन 3.9+ सभी स्निपेट्स मानक प्रकार के एनोटेशन का उपयोग करते हैं
- FXMacroData एपीआई कुंजी पर साइन अप करें /अपना नाम लिखें और खाता डैशबोर्ड से अपनी कुंजी की प्रतिलिपि
- क्रैकन खाता के तहत क्रैकन डैशबोर्ड में एपीआई कुंजी उत्पन्न करें सुरक्षा → एपीआई के साथ आदेश बनाएँ और संशोधित करें और क्वेरी फंड अनुमति
- पायथन पैकेज
requests,krakenex,pandas,schedule
pip install requests krakenex pandas scheduleसभी क्रेडेंशियल्स को पर्यावरण चर के रूप में स्टोर करें कभी हार्ड-कोड कुंजी नहींः
export FXMACRO_API_KEY="YOUR_FXMACRODATA_KEY"
export KRAKEN_API_KEY="YOUR_KRAKEN_API_KEY"
export KRAKEN_PRIVATE_KEY="YOUR_KRAKEN_PRIVATE_KEY"चरण 1: यूरो और अमरीकी डालर मैक्रो सिग्नल प्राप्त करें
विभेदन मॉडल में चार श्रृंखलाएँ प्रयोग की जाती हैं: ईसीबी नीतिगत दर, को फेड नीतिगत दर, यूरो क्षेत्र का सीपीआई, और अमेरिकी सीपीआईसाथ में वे प्रत्येक केंद्रीय बैंक के अपने बढ़ते या ढील देने के चक्र में किस स्थान पर है और मुद्रास्फीति अंतर EUR या USD की मजबूती को अनुकूल बनाता है या नहीं, इसका वर्णन करते हैं।
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 = "2023-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
ecb_rate = get_series("/announcements/eur/policy_rate")
fed_rate = get_series("/announcements/usd/policy_rate")
eur_cpi = get_series("/announcements/eur/inflation")
usd_cpi = get_series("/announcements/usd/inflation")
# Forex confirmation: EUR/USD spot trend
eurusd = get_series("/forex/eur/usd", start="2024-01-01")
# Each item: {"date": "2025-04-08", "val": 4.0, "announcement_datetime": "2025-04-08T12:15:00Z"}
print(f"ECB rate: {ecb_rate[0]['val']}%")
print(f"Fed rate: {fed_rate[0]['val']}%")
print(f"EUR CPI: {eur_cpi[0]['val']}%")
print(f"USD CPI: {usd_cpi[0]['val']}%")
print(f"EUR/USD: {eurusd[0]['val']}") announcement_datetime क्षेत्र में दूसरे स्तर के रिलीज टाइमस्टैम्प हैं, आप इसे चरण 4 में उपयोग करेंगे ताकि उच्च प्रभाव वाली घटनाओं के आसपास ट्रेडिंग को रोक सकें और रिलीज विंडो बंद होने के तुरंत बाद फिर से शुरू कर सकें।
यूरो बनाम अमरीकी डालर नीतिगत दरों में अंतर उदाहरणात्मक
जब स्प्रेड कम हो जाता है (ईसीबी फेड को पकड़ लेता है), तो EUR/USD आमतौर पर फर्म हो जाता हैं और BTC को डॉलर की कम बाधा का सामना करना पड़ता है।
चरण 2: यूआर/डॉलर मैक्रो डिवर्जेंस स्कोर की गणना करें
एक एकल संकेतक से व्यापार करने के बजाय, विचलन स्कोर -1 (मजबूत USD शासन BTC के लिए जोखिम-बहिष्करण) और +1 (कमज़ोर USD / जोखिम-निरपेक्ष शासन ?? BTC के समर्थन) के बीच एक दिशात्मक संख्या में सभी चार श्रृंखलाओं को संश्लेषित करता है। सकारात्मक स्कोर लंबे समय के लिए स्थितियों का सुझाव देते हैं; नकारात्मक स्कोर फ्लैट या लघु रहने का सुझाव देता है।
def divergence_score(
ecb_rate_pct: float,
fed_rate_pct: float,
eur_cpi_pct: float,
usd_cpi_pct: float,
eurusd_rate: float,
*,
eurusd_neutral: float = 1.08,
) -> float:
"""
Returns a composite EUR/USD macro divergence score in [-1, +1].
Positive → USD relatively weak, risk-on environment, BTC bullish.
Negative → USD relatively strong, risk-off environment, BTC bearish.
"""
score = 0.0
# Component 1: rate spread (ECB rate − Fed rate)
# Positive spread → ECB tighter than Fed → EUR-supportive → +score
rate_spread = ecb_rate_pct - fed_rate_pct
score += max(-1.0, min(1.0, rate_spread / 2.5)) * 0.35
# Component 2: inflation differential (EUR CPI − USD CPI)
# Higher EUR inflation → ECB forced to stay hawkish → EUR-supportive
infl_diff = eur_cpi_pct - usd_cpi_pct
score += max(-1.0, min(1.0, infl_diff / 3.0)) * 0.25
# Component 3: Fed hawkishness drag
# High Fed rate in absolute terms → USD strength → negative for BTC
fed_drag = (fed_rate_pct - 3.0) / 3.0 # neutral at 3 %
score -= max(-1.0, min(1.0, fed_drag)) * 0.20
# Component 4: EUR/USD spot vs neutral (1.08)
# EUR/USD above neutral → dollar relatively weak → +score
fx_signal = (eurusd_rate - eurusd_neutral) / 0.08
score += max(-1.0, min(1.0, fx_signal)) * 0.20
return max(-1.0, min(1.0, score))
score = divergence_score(
ecb_rate_pct=ecb_rate[0]["val"],
fed_rate_pct=fed_rate[0]["val"],
eur_cpi_pct=eur_cpi[0]["val"],
usd_cpi_pct=usd_cpi[0]["val"],
eurusd_rate=eurusd[0]["val"],
)
print(f"Divergence score: {score:+.3f}")
if score >= 0.25:
print("Regime: RISK-ON → consider long XBT/USD")
elif score <= -0.25:
print("Regime: RISK-OFF → consider flat / short")
else:
print("Regime: NEUTRAL → no directional edge")विभेदन स्कोर बनाम BTC/USD प्रदर्शन उदाहरणात्मक
जिन महीनों में विचलन स्कोर 0.25 से अधिक था, वे ऐतिहासिक रूप से BTC के बेहतर प्रदर्शन के अनुरूप थे। नकारात्मक शासन विस्तारित ड्रॉडाउन के साथ मेल खाते थे।
चरण 3: क्रैकन से कनेक्ट करें
krakenex पुस्तकालय सरल के साथ क्रैकन के आराम एपीआई लपेटता है query_public और query_private निजी अंत बिंदुओं (आदेशों को रखने, क्वेरी संतुलन) अपने एपीआई कुंजी जोड़ी की आवश्यकता होती है.
import krakenex
kraken = krakenex.API(
key=os.environ["KRAKEN_API_KEY"],
secret=os.environ["KRAKEN_PRIVATE_KEY"],
)
def get_balance() -> dict[str, float]:
"""Return current account balance as {asset: amount}."""
result = kraken.query_private("Balance")
if result.get("error"):
raise RuntimeError(f"Kraken balance error: {result['error']}")
return {k: float(v) for k, v in result["result"].items()}
def get_xbt_price() -> float:
"""Return latest BTC/USD mid-price from Kraken ticker."""
result = kraken.query_public("Ticker", {"pair": "XBTUSD"})
if result.get("error"):
raise RuntimeError(f"Kraken ticker error: {result['error']}")
ticker = result["result"]["XXBTZUSD"]
bid = float(ticker["b"][0])
ask = float(ticker["a"][0])
return (bid + ask) / 2.0
balance = get_balance()
usd_balance = balance.get("ZUSD", 0.0)
xbt_balance = balance.get("XXBT", 0.0)
xbt_price = get_xbt_price()
print(f"USD balance: ${usd_balance:,.2f}")
print(f"XBT balance: {xbt_balance:.6f} BTC")
print(f"XBT/USD price: ${xbt_price:,.2f}")क्रैकन परिसंपत्ति नामकरण
क्रैकन पूर्ववर्ती विरासत संपत्ति कोडः बिटकॉइन है XXBT, USD है ZUSD, EUR है ZEURएक्सबीटी/यूएसडी व्यापारिक जोड़ी की पहचान इस प्रकार की जाती है XXBTZUSD हमेशा के माध्यम से जोड़ी नाम सत्यापित करें AssetPairs आप जोड़े किसी भी नई जोड़ी के लिए सार्वजनिक अंत बिंदु.
चरण 4: ईसीबी और फेड की रिलीज़ के आसपास अनुसूची
उच्च प्रभाव वाले मैक्रो रिलीज़ ईसीबी दर निर्णय, एफओएमसी बयान, यूरोजोन सीपीआई प्रिंट आम तौर पर विदेशी मुद्रा और क्रिप्टो बाजारों दोनों में तेज अस्थिरता का इंजेक्शन देते हैं। सबसे सुरक्षित दृष्टिकोण प्रत्येक रिलीज के आसपास 30 मिनट की खिड़की में किसी भी खुली ऑर्डर गतिविधि को रोकना और मैक्रो स्कोर का तुरंत बाद पुनः मूल्यांकन करना है, इसलिए आप रिलीज से पहले के शोर के बजाय नए शासन पर व्यापार करते हैं।
एफएक्समैक्रोडाटा का रिलीज कैलेंडर प्रत्येक मुद्रा/निर्देशक जोड़ी के लिए अगली अनुसूचित घोषणा तिथि/समय को प्रदर्शित करता है, जिससे ब्लैकआउट शेड्यूलर बनाना आसान हो जाता हैः
from datetime import datetime, timezone, timedelta
def get_next_releases(currencies: list[str], indicators: list[str]) -> list[datetime]:
"""
Fetch upcoming announcement datetimes for the given
currency/indicator combinations via FXMacroData.
"""
upcoming: list[datetime] = []
for currency in currencies:
for indicator in indicators:
try:
# Fetch recent releases; announcement_datetime on future entries
# will be greater than now, while past entries will be skipped below.
data = get_series(f"/announcements/{currency}/{indicator}", start="2024-01-01")
for item in data[:6]: # scan the six most-recent entries for future datetimes
dt_str = item.get("announcement_datetime")
if dt_str:
dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
if dt > datetime.now(tz=timezone.utc):
upcoming.append(dt)
break
except (requests.RequestException, KeyError, ValueError) as exc:
log.warning("Skipping %s/%s in release calendar: %s", currency, indicator, exc)
return sorted(upcoming)
def in_blackout_window(
release_times: list[datetime],
buffer_minutes: int = 30,
) -> bool:
"""Return True if we are within buffer_minutes of any scheduled release."""
now = datetime.now(tz=timezone.utc)
for rt in release_times:
if abs((rt - now).total_seconds()) < buffer_minutes * 60:
return True
return False
# Watch ECB and Fed policy rates plus both CPI prints
WATCH_CURRENCIES = ["eur", "usd"]
WATCH_INDICATORS = ["policy_rate", "inflation", "core_inflation"]
release_times = get_next_releases(WATCH_CURRENCIES, WATCH_INDICATORS)
print("Upcoming release windows:")
for rt in release_times:
print(f" {rt.strftime('%Y-%m-%d %H:%M UTC')}")
if in_blackout_window(release_times):
print("⚠ BLACKOUT — halting order activity")
else:
print("✓ Clear to trade")चरण 5: क्रैकन पर मैक्रो-ड्राइव ऑर्डर रखें
मैक्रो स्कोर और ब्लैकआउट चेक के साथ, ऑर्डर लॉजिक सीधा है। जब स्कोर लंबी सीमा से ऊपर पार हो जाता है और कोई खुली स्थिति नहीं होती है, तो एक सीमा खरीद भेजें। जब अंक नकारात्मक हो जाता हैं या स्थिति लाभ लक्ष्य को छू जाती है, एक सीमा बेचें। स्थिति का आकार उपलब्ध USD शेष के अंश के रूप में व्यक्त किया जाता है, जो एक हार्ड अधिकतम पर है।
import math
# ── Risk parameters ──────────────────────────────────────────────────────────
LONG_THRESHOLD = 0.25 # score above this → open long
FLAT_THRESHOLD = -0.10 # score below this → close long / stay flat
MAX_POSITION_USD = 2_000 # absolute cap per trade
RISK_FRACTION = 0.10 # 10 % of USD balance per signal
LIMIT_SLIP_BPS = 5 # place limit 5 bps above mid to improve fill rate
MIN_XBT_POSITION = 0.0001 # Kraken minimum order size for XBT
def open_long(usd_amount: float, xbt_price: float) -> dict:
"""Submit a limit buy order for XBT/USD on Kraken."""
volume = round(usd_amount / xbt_price, 5)
limit_price = round(xbt_price * (1 + LIMIT_SLIP_BPS / 10_000), 2)
result = kraken.query_private("AddOrder", {
"pair": "XBTUSD",
"type": "buy",
"ordertype": "limit",
"price": str(limit_price),
"volume": str(volume),
"oflags": "post", # post-only: never pays taker fee
})
if result.get("error"):
raise RuntimeError(f"Kraken order error: {result['error']}")
return result["result"]
def close_long(xbt_volume: float, xbt_price: float) -> dict:
"""Submit a limit sell order to close an existing long."""
limit_price = round(xbt_price * (1 - LIMIT_SLIP_BPS / 10_000), 2)
result = kraken.query_private("AddOrder", {
"pair": "XBTUSD",
"type": "sell",
"ordertype": "limit",
"price": str(limit_price),
"volume": str(round(xbt_volume, 5)),
"oflags": "post",
})
if result.get("error"):
raise RuntimeError(f"Kraken order error: {result['error']}")
return result["result"]
def run_signal(score: float) -> None:
"""Execute the macro signal: open, hold, or close a XBT/USD position."""
balance = get_balance()
usd_bal = balance.get("ZUSD", 0.0)
xbt_bal = balance.get("XXBT", 0.0)
xbt_price = get_xbt_price()
has_position = xbt_bal >= MIN_XBT_POSITION # treat dust as no position
if score >= LONG_THRESHOLD and not has_position:
usd_to_deploy = min(usd_bal * RISK_FRACTION, MAX_POSITION_USD)
if usd_to_deploy < 10:
print("Insufficient USD balance for trade.")
return
result = open_long(usd_to_deploy, xbt_price)
print(f"Long opened — txid: {result.get('txid')}, "
f"volume: {result.get('descr', {}).get('order')}")
elif score <= FLAT_THRESHOLD and has_position:
result = close_long(xbt_bal, xbt_price)
print(f"Long closed — txid: {result.get('txid')}")
else:
print(f"Score {score:+.3f} — no action (position={'open' if has_position else 'flat'})")चरण 6: पूर्ण बॉट लूप इकट्ठा करें
अंतिम चरण एक अनुसूचित लूप में सब कुछ तारों है कि प्रति घंटे एक बार चलाता है. प्रत्येक टिक पर यह मैक्रो डेटा ताज़ा करता है, ब्लैकआउट खिड़कियों के लिए जाँच करता है , विचलन स्कोर को पुनः गणना करता है और संकेत निष्पादित करता है। schedule पुस्तकालय एक पूर्ण कार्य कतार की आवश्यकता के बिना इस हल्के रखता है.
import schedule
import time
import logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s",
)
log = logging.getLogger(__name__)
def bot_tick() -> None:
"""Single iteration of the macro bot."""
log.info("── Macro bot tick ──────────────────────────────────────────")
# 1. Fetch fresh macro data
try:
ecb = get_series("/announcements/eur/policy_rate")[0]["val"]
fed = get_series("/announcements/usd/policy_rate")[0]["val"]
ecpi = get_series("/announcements/eur/inflation")[0]["val"]
ucpi = get_series("/announcements/usd/inflation")[0]["val"]
fx = get_series("/forex/eur/usd")[0]["val"]
except Exception as exc:
log.error("Failed to fetch macro data: %s", exc)
return
score = divergence_score(ecb, fed, ecpi, ucpi, fx)
log.info("ECB %.2f%% Fed %.2f%% EUR CPI %.1f%% USD CPI %.1f%% EUR/USD %.4f",
ecb, fed, ecpi, ucpi, fx)
log.info("Divergence score: %+.3f", score)
# 2. Check release calendar blackout
try:
releases = get_next_releases(WATCH_CURRENCIES, WATCH_INDICATORS)
except Exception as exc:
log.warning("Release calendar fetch failed: %s — proceeding without blackout", exc)
releases = []
if in_blackout_window(releases, buffer_minutes=30):
log.warning("BLACKOUT window active — skipping order activity")
return
# 3. Execute signal
try:
run_signal(score)
except Exception as exc:
log.error("Order execution failed: %s", exc)
# Run immediately on start, then every hour
bot_tick()
schedule.every(1).hours.do(bot_tick)
log.info("Bot running — press Ctrl+C to stop")
while True:
schedule.run_pending()
time.sleep(30) # poll every 30 s so scheduled hourly tasks fire on timeकागज व्यापार पहले
क्रैकन एक समर्पित सैंडबॉक्स वातावरण का समर्थन करता है (api.demo-futures.kraken.com भावी के लिए) स्पॉट पेपर-ट्रेडिंग के लिए, वास्तविक पूंजी को तैनात करने से पहले बेहद छोटे पद आकार (जैसे, 0.0001 एक्सबीटी न्यूनतम) के साथ परीक्षण करें। प्रत्येक ऑर्डर परिणाम लॉग करें और स्केल अप करने से पूर्व कई टिक पर अपेक्षित रूप से शेष संतुलन की पुष्टि करें। RISK_FRACTION.
चरण 7: स्टॉप-लॉस और टेक-प्रॉफिट गार्ड जोड़ें
शासन स्कोर आपको बताता है कि मैक्रो पिवोट पर कब खोलना है और कब बाहर निकलना है, लेकिन इसमें दिन लग सकते हैं। इस बीच, आपको मूल्य स्तर के गार्ड की आवश्यकता है ताकि एक तेज परिसमापन कदम न निकलें।
STOP_LOSS_PCT = 0.05 # exit if price drops 5 % below entry
TAKE_PROFIT_PCT = 0.12 # exit if price rises 12 % above entry
# Store entry price in a lightweight state file
import json, pathlib
STATE_FILE = pathlib.Path("bot_state.json")
def load_state() -> dict:
if STATE_FILE.exists():
try:
return json.loads(STATE_FILE.read_text())
except (json.JSONDecodeError, OSError):
log.warning("bot_state.json is corrupt or unreadable — resetting state")
return {"entry_price": None}
def save_state(state: dict) -> None:
STATE_FILE.write_text(json.dumps(state))
def check_price_guards(xbt_price: float, xbt_bal: float) -> bool:
"""
Returns True if a stop or take-profit was triggered (position closed).
Call this before evaluating the macro score so price guards take priority.
"""
state = load_state()
entry = state.get("entry_price")
if entry is None or xbt_bal < 0.0001:
return False
pnl_pct = (xbt_price - entry) / entry
if pnl_pct <= -STOP_LOSS_PCT:
log.warning("Stop-loss triggered at %.2f%% loss — closing position", pnl_pct * 100)
close_long(xbt_bal, xbt_price)
save_state({"entry_price": None})
return True
if pnl_pct >= TAKE_PROFIT_PCT:
log.info("Take-profit triggered at %.2f%% gain — closing position", pnl_pct * 100)
close_long(xbt_bal, xbt_price)
save_state({"entry_price": None})
return True
return Falseकब? open_long सफल होता है, भरने की कीमत दर्ज करें bot_state.json. हर टिक पर, कॉल check_price_guards मैक्रो स्कोर मूल्यांकन से पहले यदि यह वापस आ जाता है True, शेष टिक को छोड़ दें क्योंकि स्थिति पहले ही मूल्य स्तर पर बंद हो चुकी है।
रणनीति का विस्तार
एक बार कोर बॉट विश्वसनीय रूप से चल रहा है, कई एक्सटेंशन पर विचार करने योग्य हैंः
- यूरो में मूल मुद्रास्फीति जोड़ें यूरो का मुख्य सीपीआई और अमरीकी डालर पीसीई मूल्य दबाव को प्रकट करते हैं; इनको मुख्य सीपीआई के साथ स्कोर में जोड़ने से मोड़ के बिंदुओं पर व्यवस्था वर्गीकरण में सुधार होता है।
- क्रैकन मार्जिन ट्रेडिंग क्रैकन एक्सबीटी/यूएसडी पर मार्जिन के साथ 5 गुना तक लीवरेज का समर्थन करता है;
"leverage": "2:1"पैरामीटरAddOrderसकारात्मक-प्रणाली संकेतों को बढ़ाने के लिए कॉल (केवल एक आनुपातिक रूप से सख्त स्टॉप-लॉस के साथ उपयुक्त) । - बहु-जोड़ी घूर्णन ईटीएच/यूएसडी के लिए एक ही व्यवस्था तर्क दोहराएं (
XETHZUSD), एक ही मैक्रो स्कोर का उपयोग करके; पूंजी को उस जोड़ी में घुमाएं जो अधिक गति दिखाता है जब दोनों जोखिम-पर शासन में हों। - दिन के भीतर विदेशी मुद्रा ओवरले EUR/USD के स्पॉट डेटा को यूरो व्यापार भारित सूचकांक अंत बिंदु और सकारात्मक मैक्रो व्यवस्था के भीतर अल्पकालिक प्रवेश फिल्टर के रूप में दिन के भीतर गति का उपयोग करें।
- वेबसॉकेट ऑर्डर बुक वास्तविक समय में मूल्य अद्यतन के लिए क्रैकन के वेबसोकेट फीड के साथ निर्धारित मतदान लूप को प्रतिस्थापित करें, प्रवेश और निकास परिष्करण के लिए विलंबता को मिनटों से मिलीसेकंड तक कम करें।
स्कोर व्यवस्था का विभाजन चित्रणात्मक वितरण
2023-2025 के चक्र में, जोखिम-पर और तटस्थ व्यवस्थाओं ने लगभग दो तिहाई कैलेंडर दिनों का प्रतिनिधित्व किया, जिससे पर्याप्त लंबी अवसर खिड़कियां प्रदान की गईं।
सारांश और आगे के कदम
अब आपके पास एक पूर्ण पायथन ट्रेडिंग बॉट है जो EUR/USD मैक्रो विचलन को क्रैकन पर कार्रवाई योग्य लंबे/फ्लैट संकेतों में अनुवाद करता है। प्रमुख घटक हैंः
- FXMacroData संकेतक खींचता है ECB और फेड दरें, EUR और USD CPI, EUR/USD स्पॉट, सभी
/announcements/और/forex/दूसरे स्तर के समय के साथ अंत बिंदु - विचलन स्कोर एक भारित कम्पोजिट जो एक दिशा संकेत पर कई संकेतकों को मैप करता है
- ब्लैकआउट शेड्यूलर ECB और Fed के रिलीज़ विंडो के आसपास ऑर्डर गतिविधि को रोकता है FXMacroData रिलीज़ कैलेंडर
- क्रैकन आदेश प्रबंधन शुल्क को कम करने के लिए केवल पोस्ट-फ्लैग के साथ खरीद और बिक्री को सीमित करें
- मूल्य रक्षकों स्टॉप लॉस और टेक प्रॉफिट के स्तर जो मैक्रो सिस्टम पिव्होट्स के बीच की स्थिति की रक्षा करते हैं
एक स्वाभाविक कदम के रूप में, खोज करें अमरीकी डालर पीसीई और यूरो का मुख्य सीपीआई स्कोर के मुद्रास्फीति घटकों को तेज करने के लिए, या एक स्पॉट FX स्थिति के साथ एक ही व्यवस्था संकेत का उपयोग कर सीधे Kraken पर EUR/USD जोड़ी का व्यापार करने के बॉट का विस्तार करने के।
पूर्ण एपीआई संदर्भ और सभी उपलब्ध मुद्रा/निर्देशक संयोजन /api- संदर्भ. अपनी एपीआई कुंजी प्राप्त करने के लिए, /अपना नाम लिखें.
