How to Use COT Data to Filter FX Trade Entries

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

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

पूर्व शर्तें

• FXMacroData एपीआई कुंजी उपलब्ध /अपना नाम लिखेंसीओटी अंत बिंदु सभी भुगतान योजनाओं में शामिल है।
• पायथन 3.9+ के साथ requests पुस्तकालय स्थापित (pip install requests) ।
• सीओटी रिपोर्ट शब्दावली (गैर-वाणिज्यिक लॉन्ग, शॉर्ट्स, ओपन इंटरेस्ट) के साथ बुनियादी परिचितता। विदेशी मुद्रा व्यापारियों के लिए सीओटी रिपोर्ट गाइड मूलभूत बातों को कवर करता है।
• वैकल्पिक रूप से, pandas डेटा हेरफेर के चरणों के लिए (pip install pandas) ।

चरण 1 एपीआई से सीओटी डेटा प्राप्त करें

FXMacroData COT एंडपॉइंट मुद्रा वायदा के लिए साप्ताहिक गैर-वाणिज्यिक और वाणिज्यिक स्थिति देता है। समर्थित मुद्राएं AUD, CAD, CHF, EUR, GBP, JPY, NZD, और USD हैं। प्रत्येक रिकॉर्ड में गैर-व्यावसायिक और व्यावसायिक प्रतिभागियों के लिए लंबे, छोटे और शुद्ध अनुबंध की गिनती होती है, साथ ही कुल खुली ब्याज भी शामिल है।

curl "https://fxmacrodata.com/api/v1/cot/eur?api_key=YOUR_API_KEY&start=2023-01-01"

प्रतिक्रिया JSON का यह संरचना हैः

{
  "currency": "eur",
  "data": [
    {
      "date": "2025-03-25",
      "noncommercial_long": 198432,
      "noncommercial_short": 61840,
      "noncommercial_net": 136592,
      "commercial_long": 68230,
      "commercial_short": 201860,
      "open_interest": 591400
    },
    {
      "date": "2025-03-18",
      "noncommercial_long": 185710,
      "noncommercial_short": 66320,
      "noncommercial_net": 119390,
      "commercial_long": 72140,
      "commercial_short": 189430,
      "open_interest": 578200
    }
  ]
}

पायथन में, इस कॉल को एक सहायक में लपेटें जो समयानुसार क्रमबद्ध डेटा सूची लौटाता हैः

import requests
from datetime import date, timedelta

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY  = "YOUR_API_KEY"


def fetch_cot(currency: str, lookback_days: int = 365) -> list[dict]:
    """Return COT weekly records for *currency* over the last *lookback_days* days."""
    start = (date.today() - timedelta(days=lookback_days)).isoformat()
    resp = requests.get(
        f"{BASE_URL}/cot/{currency.lower()}",
        params={"api_key": API_KEY, "start": start},
        timeout=15,
    )
    resp.raise_for_status()
    payload = resp.json()
    return sorted(payload["data"], key=lambda r: r["date"])


records = fetch_cot("eur")
print(f"Loaded {len(records)} COT records for EUR")
print("Latest:", records[-1])

चरण 2 व्युत्पन्न पोजिशनिंग मीट्रिक्स की गणना करें

कच्चे अनुबंधों की संख्या की तुलना करें मुद्राओं और समय के साथ करना मुश्किल है। 80,000 अनुबंध की शुद्ध लंबाई का अर्थ EUR वायदा (बड़ा, तरल बाजार) बनाम CHF (छोटा खुला ब्याज) में बहुत अलग है। दो व्युत्पन्न मीट्रिक इसे हल करते हैं।

2अ. खुली ब्याज की प्रतिशत के रूप में शुद्ध स्थिति

गैर-वाणिज्यिक शुद्ध स्थिति को कुल खुली ब्याज से विभाजित करने से -1 और +1 के बीच एक सामान्यीकृत अनुपात प्राप्त होता है। इससे मीट्रिक सीधे मुद्राओं और समय के साथ तुलनीय हो जाता है।

def net_pct_oi(records: list[dict]) -> list[dict]:
    """Add 'net_pct' field = noncommercial_net / open_interest to each record."""
    enriched = []
    for r in records:
        oi = r.get("open_interest") or 1  # guard against zero
        enriched.append({**r, "net_pct": r["noncommercial_net"] / oi})
    return enriched


records = net_pct_oi(records)
latest  = records[-1]
print(f"EUR net % OI: {latest['net_pct']:.3f}  ({latest['date']})")

2बी. पोजिशनिंग पर्सेंटाइल रैंक

यह जानने के लिए कि वर्तमान स्थिति चरम है या नहीं, आपको ऐतिहासिक संदर्भ की आवश्यकता है। net_pct पिछली खिड़की के भीतर एक पूर्ण संख्या को प्रतिशत में परिवर्तित करता है (0 = रिकॉर्ड पर सबसे अधिक मंदी, 100 = सबसे अधिक तेजी) । 75 से ऊपर का प्रतिशत भीड़ भरे लंबे समय का संकेत देता है; 25 से नीचे भीड़ भरे शॉर्ट का संकेत होता है।

def percentile_rank(series: list[float], value: float) -> float:
    """Return the percentile rank of *value* within *series* (0–100)."""
    below = sum(1 for x in series if x < value)
    return below / len(series) * 100


net_series     = [r["net_pct"] for r in records]
current_net    = records[-1]["net_pct"]
pct_rank       = percentile_rank(net_series, current_net)

print(f"EUR positioning percentile: {pct_rank:.1f}th")

2c. पोजिशनिंग इम्पम्पोटम

प्रवृत्ति दिशा वर्तमान स्तर के रूप में ज्यादा मायने रखती है. एक नेट लंबी जो बढ़ रही है एक अलग संकेत है एक नेट लंबे समय से जो एक plateaued या सिकुड़ने के लिए शुरू कर दिया है. गति को पकड़ने के net_pct में 4 सप्ताह के परिवर्तन की गणना करें:

def positioning_momentum(records: list[dict], periods: int = 4) -> float:
    """Return the change in net_pct over the last *periods* weeks."""
    if len(records) < periods + 1:
        return 0.0
    return records[-1]["net_pct"] - records[-(periods + 1)]["net_pct"]


momentum = positioning_momentum(records)
print(f"EUR 4-week positioning change: {momentum:+.3f}")

चरण 3 प्रवेश फ़िल्टर बनाएं

हाथ में तीन मीट्रिक के साथ, आप एक फ़िल्टर फ़ंक्शन का निर्माण कर सकते हैं जो किसी भी मुद्रा के लिए एक दिशात्मक संकेत देता है। तर्क वर्तमान स्तर, प्रतिशत संदर्भ और गति दिशा को एक ही गेट में जोड़ता है।

def cot_entry_filter(
    currency: str,
    lookback_days: int = 365,
    long_pct_threshold: float = 55.0,
    short_pct_threshold: float = 45.0,
    momentum_min: float = 0.005,
) -> dict:
    """
    Return a COT positioning signal for *currency*.

    Parameters
    ----------
    currency            : ISO currency code (AUD, CAD, CHF, EUR, GBP, JPY, NZD, USD)
    lookback_days       : history window for percentile calculation
    long_pct_threshold  : minimum percentile to confirm a long bias
    short_pct_threshold : maximum percentile to confirm a short bias
    momentum_min        : minimum absolute 4-week change to confirm momentum

    Returns
    -------
    dict with keys: currency, signal, net_pct, percentile, momentum, date
    """
    records  = fetch_cot(currency, lookback_days)
    records  = net_pct_oi(records)
    latest   = records[-1]

    net_series = [r["net_pct"] for r in records]
    pct_rank   = percentile_rank(net_series, latest["net_pct"])
    momentum   = positioning_momentum(records)

    if pct_rank >= long_pct_threshold and momentum >= momentum_min:
        signal = "long"
    elif pct_rank <= short_pct_threshold and momentum <= -momentum_min:
        signal = "short"
    else:
        signal = "neutral"

    return {
        "currency"   : currency.upper(),
        "signal"     : signal,
        "net_pct"    : round(latest["net_pct"], 4),
        "percentile" : round(pct_rank, 1),
        "momentum"   : round(momentum, 4),
        "date"       : latest["date"],
    }


result = cot_entry_filter("eur")
print(result)

नमूना आउटपुट जब EUR गैर वाणिज्यिक भीड़ भरे लंबे समय से चल रहे हैं और इसके लिए जोड़ रहे हैंः

{
  "currency"  : "EUR",
  "signal"    : "long",
  "net_pct"   : 0.231,
  "percentile": 82.4,
  "momentum"  : 0.018,
  "date"      : "2025-03-25"
}

चरण 4 फ़िल्टर को व्यापार प्रविष्टियों पर लागू करें

फ़िल्टर फ़ंक्शन तीन संकेतों में से एक को लौटाता है long, short, या neutral. इसका उपयोग आपके प्राथमिक प्रवेश संकेत के आगे एक गेट के रूप में किया जाता हैः केवल लंबे सेटअप लें जब COT फ़िल्टर कहता है long (या neutral यदि आप अधिक आक्रामक हैं), और केवल संक्षिप्त सेटअप लें जब COT फ़िल्टर कहता है short.

def should_enter_trade(
    currency: str,
    proposed_direction: str,
    allow_neutral: bool = False,
) -> bool:
    """
    Return True if COT positioning supports *proposed_direction* for *currency*.

    Parameters
    ----------
    currency           : ISO currency code
    proposed_direction : 'long' or 'short'
    allow_neutral      : if True, a 'neutral' COT signal does not block entry
    """
    cot = cot_entry_filter(currency)
    if cot["signal"] == proposed_direction:
        return True
    if allow_neutral and cot["signal"] == "neutral":
        return True
    return False


# Example: checking whether to enter a EUR/USD long
currency = "eur"   # base currency of the pair
direction = "long"

if should_enter_trade(currency, direction):
    print(f"COT confirms {direction} bias for {currency.upper()} — proceed to entry check")
else:
    print(f"COT filter blocked {direction} entry for {currency.upper()}")

चरण 5 बहु-मुद्रा डैशबोर्ड तक विस्तारित करें

एक बार में सभी आठ समर्थित मुद्राओं पर फ़िल्टर चलाने से आपको साप्ताहिक पोजिशनिंग डैशबोर्ड मिलता है। यह यह पहचानने के लिए उपयोगी है कि कौन से विदेशी मुद्रा जोड़े सबसे स्पष्ट सट्टेबाज-संचालित टेलविंड्स हैं और किनसे बचने के कारण पोजिशनिंग आपकी दिशा के खिलाफ काम कर रही है।

CURRENCIES = ["aud", "cad", "chf", "eur", "gbp", "jpy", "nzd", "usd"]

def cot_dashboard() -> list[dict]:
    """Return COT positioning signals for all supported currencies."""
    results = []
    for ccy in CURRENCIES:
        try:
            result = cot_entry_filter(ccy)
            results.append(result)
        except Exception as exc:
            print(f"Warning: could not load {ccy.upper()} COT data — {exc}")
    return results


dashboard = cot_dashboard()
for row in dashboard:
    bar = "▲" if row["signal"] == "long" else ("▼" if row["signal"] == "short" else "–")
    print(f"{row['currency']:4s}  {bar} {row['signal']:8s}  pct={row['percentile']:5.1f}  mom={row['momentum']:+.3f}")

साप्ताहिक नमूना उत्पादनः

AUD   ▲ long      pct= 71.2  mom=+0.012
CAD   – neutral   pct= 53.8  mom=-0.004
CHF   ▲ long      pct= 68.4  mom=+0.008
EUR   ▲ long      pct= 82.4  mom=+0.018
GBP   – neutral   pct= 48.1  mom=-0.002
JPY   ▼ short     pct= 19.6  mom=-0.022
NZD   ▲ long      pct= 63.0  mom=+0.007
USD   ▼ short     pct= 22.1  mom=-0.015

इस स्नैपशॉट को पढ़नाः गैर-वाणिज्यिक EUR, AUD, CHF और NZD वायदा पर लंबे समय तक तैनात हैं; JPY और USD पर कम; और CAD और GBP पर तटस्थ। एक ट्रेडर जो EUR/JPY लॉन्ग पर विचार करता है, उसे दोनों पैरों की पुष्टि सट्टेबाज प्रवाह द्वारा मिलेगी। एक व्यापारी जो USD/CAD लॉन्ज पर विचार कर रहा है, को USD पर एक COT विपरीत हवा और CAD पर एक तटस्थ पृष्ठभूमि का सामना करना पड़ेगा।

चरण 6 एक मैक्रो पुष्टिकरण परत के साथ COT को जोड़ें

सबसे मजबूत सेटअप में सीओटी पोजिशनिंग को कम से कम एक मैक्रो फंडामेंटल के साथ जोड़ा जाता है जो एक ही दिशात्मक थीसिस का समर्थन करता है। दर अंतर प्राकृतिक पूरक हैंः यदि सट्टेबाज यूरो को लंबे समय तक रखते हैं और ईसीबी-फेड दर अंतर यूरो के पक्ष में बढ़ रहा है, तो पोजिशनिंग और मौलिक मामला संरेखित होते हैं।

का उपयोग करें नीतिगत दर का अंतिम बिंदु प्रत्येक मुद्रा के लिए नवीनतम दर निकालने और अंतर की गणना करने के लिएः

def fetch_latest_rate(currency: str) -> float | None:
    """Return the most recent policy rate for *currency* as a float."""
    resp = requests.get(
        f"{BASE_URL}/announcements/{currency.lower()}/policy_rate",
        params={"api_key": API_KEY, "limit": 1},
        timeout=15,
    )
    if resp.status_code != 200:
        return None
    data = resp.json().get("data", [])
    return data[0]["val"] if data else None


def rate_differential(base_ccy: str, quote_ccy: str) -> float | None:
    """Return base_rate − quote_rate, or None if either rate is unavailable."""
    base_rate  = fetch_latest_rate(base_ccy)
    quote_rate = fetch_latest_rate(quote_ccy)
    if base_rate is None or quote_rate is None:
        return None
    return base_rate - quote_rate


def combined_filter(base_ccy: str, quote_ccy: str, direction: str) -> dict:
    """
    Return a combined COT + rate-differential signal for a currency pair.

    direction : 'long' (buy base) or 'short' (sell base)
    """
    cot_base   = cot_entry_filter(base_ccy)
    cot_quote  = cot_entry_filter(quote_ccy)
    diff       = rate_differential(base_ccy, quote_ccy)

    # For a long (buy base): we want long bias on base AND short/neutral on quote
    if direction == "long":
        cot_ok   = cot_base["signal"] == "long" and cot_quote["signal"] != "long"
        macro_ok = diff is not None and diff > 0
    else:
        cot_ok   = cot_base["signal"] == "short" and cot_quote["signal"] != "short"
        macro_ok = diff is not None and diff < 0

    return {
        "pair"       : f"{base_ccy.upper()}/{quote_ccy.upper()}",
        "direction"  : direction,
        "cot_ok"     : cot_ok,
        "macro_ok"   : macro_ok,
        "confirmed"  : cot_ok and macro_ok,
        "cot_base"   : cot_base,
        "cot_quote"  : cot_quote,
        "rate_diff"  : round(diff, 4) if diff is not None else None,
    }


signal = combined_filter("eur", "jpy", "long")
print("Confirmed:", signal["confirmed"])
print("COT base :", signal["cot_base"]["signal"], "| COT quote:", signal["cot_quote"]["signal"])
print("Rate diff :", signal["rate_diff"])

सारांश

आपके पास अब एक पूर्ण COT आधारित प्रविष्टि फ़िल्टर है जो लाइव FXMacroData API डेटा पर बनाया गया है. कार्यप्रवाह में छह चरण शामिल हैंः

1. आप जिस मुद्रा या मुद्राओं का व्यापार कर रहे हैं उसके लिए साप्ताहिक सीओटी रिकॉर्ड प्राप्त करें।
2. मुद्राओं के बीच सामान्यीकरण के लिए शुद्ध स्थिति को खुले ब्याज के प्रतिशत के रूप में गणना की जाए।
3. चरम या तटस्थ परिस्थितियों की पहचान करने के लिए पिछले वर्ष के भीतर वर्तमान स्थिति को रैंक करें।
4. यह पुष्टि करने के लिए 4 सप्ताह की गति की गणना करें कि क्या स्थिति आपके पक्ष में प्रवृत्ति है।
5. फ़िल्टर सिग्नल के विरुद्ध अपने व्यापार प्रविष्टियों को गेट करें केवल तभी आगे बढ़ें जब सीओटी संरेखण आपकी दिशा से मेल खाता हो।
6. दो-कारक पुष्टि के लिए वैकल्पिक रूप से दर-अंतर जांच के साथ संयोजन करें।

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