Der Begriff „Neuzeichnung“ ist im Aktienmarkt jedem vertraut. Vorab Zeichnungsrechte sichern und dann zum offiziellen Börsengang von der Preisfindung profitieren – das ist der Kern der Neuzeichnung. Auch im Kryptobereich gibt es Neuzeichnungsmöglichkeiten, und zwar deutlich häufiger als an der Börse. Große zentralisierte Börsen listen fast alle paar Tage neue Perpetual Contracts, und diese Chancen stehen jedem offen.

In der Anfangsphase nach Listung eines Perpetual Contracts ist der Marktpreis noch nicht vollständig ermittelt, die Preiselastizität ist extrem hoch, und oft kommt es innerhalb kurzer Zeit zu Kursbewegungen, die weit über normale Schwankungen hinausgehen. Die Richtung frühzeitig zu erkennen und zum Eröffnungszeitpunkt einzusteigen – genau darin liegt die Chance des Neuzeichnens von Perpetual Contracts. Aber hier liegt auch das Problem: Vor der Listung eines neuen Contracts wissen wir so gut wie nichts über diesen Coin. Teamhintergrund, Tokenomics, Marktstimmung, Funding Rate … all diese Informationen erfordern viel Zeit zum Sammeln und Analysieren. Ohne ausreichende Kenntnisse einfach einzusteigen, unterscheidet sich kaum vom Glücksspiel. Mit manueller Recherche zu jedem neuen Coin kommt man gar nicht hinterher.

Der heute vorgestellte Workflow soll dieses Problem lösen – das System beginnt automatisch mit der Datenerfassung, sobald die Ankündigung veröffentlicht wird, führt kontinuierlich KI-Analysen durch und hilft uns, vor dem Börsenstart eine ausreichende Wissensbasis aufzubauen. Der gesamte Workflow läuft rund um die Uhr automatisch, ohne manuelle Überwachung. Neue Coin-Ankündigungen, Datenerfassung, KI-Analyse, Einstieg bei Eröffnung – alles läuft automatisch ab.

Gesamtarchitektur: zwei parallele Ausführungslinien

Die Architektur dieser Strategie besteht aus zwei Ausführungslinien.

Die Analyse-Linie läuft in längeren Intervallen zyklisch und ist dafür verantwortlich, kontinuierlich neue Coin-Listungsankündigungen zu überwachen, mehrdimensionale Daten zu sammeln, KI-Analysen durchzuführen und jede Analyseergebnis als Historie zu speichern. Die Ausführungslinie läuft in sehr kurzen Intervallen hochfrequent zyklisch und ist dafür zuständig, in Echtzeit zu prüfen, ob ein neuer Coin bereits an der Börse gelistet ist. Sobald eine Listung erkannt wird, werden sofort die Analyseergebnisse gelesen, entschieden, ob ein Einstieg erfolgt, und anschließend die Take-Profit- und Stop-Loss-Positionen der offenen Positionen überwacht.

Die beiden Linien haben klare Aufgaben – die Analyse-Linie liefert die Richtung, die Ausführungslinie setzt sie um.

Analyse-Linie: Schritt 1 – Neue Coins erkennen und Tracking-Queue aufbauen

Nach dem Start initialisiert die Analyse-Linie zunächst den globalen Zustand, erfasst Basisdaten wie Anfangskapital, Anzahl der Durchläufe usw.:

            javascript
            
            
if (_G('nl_initialized') === null) {
  _G('nl_initialized', true);
  _G('nl_trackingList', JSON.stringify([]));
  _G('nl_STARTTIME', Date.now());
  const initAccount = exchange.GetAccount();
  _G('nl_initmoney', $vars.initmoney || initAccount.Balance);
}

Dann werden die offiziellen Ankündigungen von Binance abgerufen, um neue Coins zu identifizieren, die demnächst als Perpetual Contract gelistet werden:

            javascript
            
            
const raw = HttpQuery(
  'https://www.binance.com/bapi/composite/v1/public/cms/article/list/query?type=1&pageNo=1&pageSize=10',
  { method: 'GET', headers: { 'User-Agent': 'Mozilla/5.0', 'clienttype': 'web' } }
);

Sobald ein neuer Coin erkannt wird, schiebt das System ihn in die Tracking-Queue und markiert seinen Status: Vor der Listung PRE_LISTING (Vorab-Tracking), am Listungstag Wechsel zu LAUNCH_DAY (Eröffnungstag), nach dem Einstieg TRADING (im Handel), nach Abschluss auf DONE gesetzt und automatisch aus der Queue entfernt.

            javascript
            
            
trackingList.push({
  symbol,
  launchDate,
  status: isLaunchDay ? 'LAUNCH_DAY' : 'PRE_LISTING',
  discoveredAt: now.toISOString(),
  hoursToLaunch: isLaunchDay ? '今日发行' : hoursToLaunch,
  analysisCount: 0,
  lastAnalyzedAt: null
});

So behält das System stets nur die aktuell wirklich wertvollen Ziele im Blick und verschwendet keine Mühe auf bereits abgelaufene Chancen.

Analyse-Linie: Schritt 2 – Mehrdimensionale Datenerfassung

Nachdem ein neuer Coin entdeckt wurde, beginnt das System sofort mit der Datenerfassung aus drei Dimensionen.

Fundamentaldaten werden über die CoinMarketCap-API abgerufen, darunter Marktkapitalisierung, Umlaufverhältnis, CMC-Ranking usw.:

            javascript
            
            
function fetchCMC(coin) {
  const key = $vars.cmcApiKey || '';
  const raw = HttpQuery(
    'https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest?symbol=' + coin + '&convert=USD',
    { method: 'GET', headers: { 'X-CMC_PRO_API_KEY': key, 'Accept': 'application/json' } }
  );
  const c = JSON.parse(raw).data[coin];
  const q = c.quote.USD;
  const supply = c.max_supply || c.total_supply;
  return {
    name: c.name, rank: c.cmc_rank,
    circulatingSupply: c.circulating_supply,
    circulationRatio: supply
      ? parseFloat((c.circulating_supply / supply * 100).toFixed(2))
      : null,
    spotPrice: q.price,
    change1h: q.percent_change_1h,
    change24h: q.percent_change_24h,
    change7d: q.percent_change_7d,
    volume24h: q.volume_24h,
    marketCap: q.market_cap,
    fullyDilutedMarketCap: q.fully_diluted_market_cap
  };
}

Stimmungsdaten werden über die Brave Search API abgerufen, um aktuelle Nachrichten über den Coin zu sammeln, die sich auf Finanzierungshintergrund, Teamdynamik, Freigabepläne usw. beziehen. Es werden drei verschiedene Keywords-Kombinationen verwendet:

            javascript
            
            
function fetchBraveNews(coin) {
  const key = $vars.braveKey || '';
  const queries = [
    '"' + coin + '" token funding team',
    '"' + coin + '" vesting unlock schedule',
    '"' + coin + '" binance futures listing'
  ];
  // Für jede query die Brave Search API aufrufen, Ergebnisse filtern, die den Coin-Namen enthalten, Duplikate entfernen und zurückgeben
}

Marktdaten werden gleichzeitig von den Börsen Bybit, OKX, Gate und HTX abgerufen, darunter wichtige Kennzahlen wie Funding Rate, Open Interest und Spread. Am Beispiel OKX:

            javascript
            
            
function fetchOKX(coin) {
  try {
    const instId = coin + '-USDT-SWAP';
    const tkRaw = HttpQuery('https://www.okx.com/api/v5/market/ticker?instId=' + instId,
      { method: 'GET', headers: { 'Accept': 'application/json' } });
    const tk = JSON.parse(tkRaw).data && JSON.parse(tkRaw).data[0];
    if (!tk) return null;
    Sleep(150);

    let fundingRate = null, nextFundingRate = null, fundingTime = null, nextFundingTime = null;
    try {
      const frRaw = HttpQuery('https://www.okx.com/api/v5/public/funding-rate?instId=' + instId,
        { method: 'GET', headers: { 'Accept': 'application/json' } });
      const fr = JSON.parse(frRaw).data && JSON.parse(frRaw).data[0];
      if (fr) {
        fundingRate = parseFloat(fr.fundingRate);
        nextFundingRate = fr.nextFundingRate !== '' ? parseFloat(fr.nextFundingRate) : null;
        fundingTime = fr.fundingTime;
        nextFundingTime = fr.nextFundingTime;
      }
    } catch(e) {}
    Sleep(150);

    let openInterest = null;
    try {
      const oiRaw = HttpQuery('https://www.okx.com/api/v5/public/open-interest?instType=SWAP&instId=' + instId,
        { method: 'GET', headers: { 'Accept': 'application/json' } });
      const oiData = JSON.parse(oiRaw).data && JSON.parse(oiRaw).data[0];
      if (oiData) openInterest = parseFloat(oiData.oiUsd);
    } catch(e) {}

    const last = parseFloat(tk.last);
    const sodUtc0 = parseFloat(tk.sodUtc0);

    return {
      price: last,
      bid1: parseFloat(tk.bidPx), bid1Size: parseFloat(tk.bidSz),
      ask1: parseFloat(tk.askPx), ask1Size: parseFloat(tk.askSz),
      spread: parseFloat((parseFloat(tk.askPx) - parseFloat(tk.bidPx)).toFixed(8)),
      change24h: parseFloat(((last - sodUtc0) / sodUtc0 * 100).toFixed(4)),
      high24h: parseFloat(tk.high24h), low24h: parseFloat(tk.low24h), open24h: parseFloat(tk.open24h),
      volume24h: parseFloat(tk.vol24h), volCcy24h: parseFloat(tk.volCcy24h),
      openInterest,
      fundingRate, nextFundingRate, fundingTime, nextFundingTime
    };
  } catch(e) { Log('OKX fehlgeschlagen:', e.message); return null; }
}

Die mehrfache Börsen-Validierung reduziert effektiv Verzerrungen durch eine einzelne Datenquelle und bietet ein umfassenderes Verständnis neuer Coins.

Analyse-Linie: Schritt 3 – KI-Analyse mit historischem Gedächtnis

Dies ist das Kernstück des gesamten Workflows.

Vom Zeitpunkt der Ankündigung bis zur offiziellen Listung eines neuen Coins vergehen oft mehrere Tage. Während dieser Zeit sammelt das System wiederholt Daten und führt wiederholt KI-Analysen durch. Der entscheidende Punkt ist: Bei jeder Analyse werden alle bisherigen Schlussfolgerungen zusammen mit der KI geteilt, sodass diese auf Basis der historischen Urteile neue Schlüsse ziehen kann.

Lesen des Verlaufs und Einfügen in den Prompt:

            javascript
            
            
const historyKey = 'nl_history_' + symbol;
const history = JSON.parse(_G(historyKey) || '[]');
const orderNum = history.length + 1;

function buildHistorySection(history) {
  if (history.length === 0) return '(Dies ist die erste Analyse für diesen Coin; es gibt noch keine Historie.)';
  return history.map(h => {
    const ai = h.aiConclusion;
    return [
      '### ' + h.order + '. Analyse',
      '- Zeit: ' + h.timestamp + ' | Bis zur Listung: ' + h.hoursToLaunch + ' | Phase: ' + h.phase,
      '- Ergebnis: ' + ai.direction + ', Konfidenz: ' + ai.confidence + '%, Risiko: ' + ai.riskLevel,
      '- Trend: ' + (ai.trendConsistency || 'Initial'),
      '- Einstiegszeitpunkt: ' + (ai.entryTiming || '-'),
      '- Gesamturteil: ' + ai.summary
    ].join('\n');
  }).join('\n\n');
}

Die KI-Analyse folgt mehreren Kernprinzipien: Bei konsistenter historischer Richtung steigt die Konfidenz mit jeder Analyse; bei einem Richtungswechsel muss klar angegeben werden, ob es sich um ein echtes Signal oder kurzfristiges Rauschen handelt; wenn die historischen Urteile schwanken, bleibt die Konfidenz konservativ und wird nicht blind erhöht. Die KI gibt schließlich ein strukturiertes Ergebnis aus:

            javascript
            
            
// Von der KI ausgegebene JSON-Struktur
{
  "order": 3,
  "direction": "long|short|hold",
  "confidence": 76,                      // Ganzzahl 0-100
  "trendConsistency": "initial|strengthening|stable|weakening|reversal",
  "reversalType": "echtes Signal|kurzfristiges Rauschen|null",
  "entryTiming": "immediate|drawdown_N", // drawdown_5 bedeutet auf 5% Rückzug warten
  "priceRange": { "low": 128, "high": 130 },
  "leverage": 10,
  "stopLoss": 5,                         // Stop-Loss-Prozentsatz
  "takeProfit": 15,                      // Take-Profit-Prozentsatz
  "riskLevel": "hoch|mittel|niedrig",
  "riskPoints": ["Risikopunkt 1", "Risikopunkt 2"],
  "keyChanges": "Wichtigste Datenänderungen im Vergleich zum letzten Mal",
  "summary": "Gesamturteil in max. 100 Zeichen"
}

Nach Abschluss der Analyse wird das Ergebnis im Verlauf gespeichert und gleichzeitig die endgültige Strategie für diesen Coin aktualisiert, die von der Ausführungslinie gelesen werden kann.

            javascript
            
            
const record = {
  order: item.orderNum,
  timestamp: new Date().toISOString(),
  phase: item.status,
  hoursToLaunch: item.hoursToLaunch,
  currentData: item.currentData,
  aiConclusion: aiResult
};
history.push(record);
_G('nl_history_' + symbol, JSON.stringify(history));

_G('nl_strategy_' + symbol, JSON.stringify({
  symbol,
  updatedAt: new Date().toISOString(),
  phase: item.status,
  historyCount: history.length,
  aiResult
}));

Wenn die Richtung stets gleich bleibt, steigt die Konfidenz mit jeder Analyse. Tritt jedoch eine Richtungsumkehr auf, muss die KI einen klaren Grund liefern. So werden die gesammelten Urteile weitaus zuverlässiger als eine einzelne unabhängige Analyse.

Ausführungslinie: Schritt 4 – Listing-Erkennung und sicherer Einstieg

Die Hochfrequenz-Schleife der Ausführungslinie prüft über exchange.GetMarkets(), ob eine neue Coin bereits im Kontrakthandel der Börse gelistet ist. Sobald ein Listing erkannt wird, erfolgt zunächst eine Sicherheitsprüfung:

            javascript
            
            
if (ai.direction === '观望') { updateStatus(symbol, 'DONE'); continue; }
if (ai.riskLevel === '高')   { updateStatus(symbol, 'DONE'); continue; }
if (ai.confidence < CONFIG.MIN_CONFIDENCE) { updateStatus(symbol, 'DONE'); continue; }
if (hasPosition(coin)) { updateStatus(symbol, 'TRADING'); continue; }

Nach bestandener Prüfung wird entsprechend dem von der KI empfohlenen Einstiegszeitpunkt gehandelt. Bei sofortigem Einstieg wird die Kontraktmenge berechnet und die Order direkt platziert:

            javascript
            
            
const leverage = Math.min(ai.leverage || 5, CONFIG.MAX_LEVERAGE);
exchange.SetMarginLevel(leverage);

const allocAmount = Math.min(CONFIG.POSITION_AMOUNT, account.Balance * 0.3);
const qty = calcContractAmount(allocAmount, price, market);

if (ai.direction === '做多') {
  exchange.SetDirection('buy');
  orderId = exchange.Buy(-1, qty);
} else if (ai.direction === '做空') {
  exchange.SetDirection('sell');
  orderId = exchange.Sell(-1, qty);
}

Bewertet die KI die Eröffnungsprämie als zu hoch und empfiehlt, auf einen Rücksetzer zu warten, zeichnet das System den Zielkurs auf und pollt fortlaufend:

            javascript
            
            
const targetPrice = ai.direction === '做多'
  ? openPrice * (1 - pct / 100)
  : openPrice * (1 + pct / 100);

_G(coin + '_nl_waitEntry', JSON.stringify({
  type: 'drawdown',
  waitStartTime: Date.now(),
  openPrice, targetPrice, drawdownPct: pct, ai
}));
updateStatus(symbol, 'TRADING_WAIT');

Wird der Zielkurs innerhalb von 2 Stunden nicht erreicht, gilt die Gelegenheit als verpasst und der Einstieg wird automatisch abgebrochen.

Ausführungslinie: Schritt 5 – Positionsüberwachung, Take-Profit und Stop-Loss

Nach dem Einstieg überwacht die Ausführungslinie kontinuierlich die Position. Take-Profit und Stop-Loss laufen parallel in zwei Mechanismen:

            javascript
            
            
const TP_SL = {
  DEFAULT_SL:        10,  // Standard-Stop-Loss 10%
  DEFAULT_TP:        25,  // Standard-fester Take-Profit 25%
  TRAILING_TRIGGER:  30,  // Trailing-Stop aktiviert bei 30% Gewinn
  TRAILING_DRAWDOWN:  8   // Trailing-Rücksetzer 8%
};

// Aktualisiere den maximalen Gewinn
if (pnlPct / 100 > maxProfit) {
  maxProfit = pnlPct / 100;
  _G(maxProfitKey, maxProfit);
}

// Bei Erreichen der Schwelle wird der Trailing-Stop automatisch aktiviert
if (tpDrawdown === 0 && maxPnlPct >= TP_SL.TRAILING_TRIGGER) {
  tpDrawdown = TP_SL.TRAILING_DRAWDOWN;
  _G(tpDrawKey, tpDrawdown);
}

// Prüfe nacheinander drei Schließbedingungen: welche zuerst eintritt, wird ausgeführt
let closeReason = null;
if (tpDrawdown > 0 && drawdown >= tpDrawdown) closeReason = '移动止盈';
if (!closeReason && pnlPct <= -maxSL)          closeReason = '止损';
if (!closeReason && pnlPct >= entry.takeProfit) closeReason = '固定止盈';

if (closeReason) {
  if (isLong) { exchange.SetDirection('closebuy');  exchange.Sell(-1, amount); }
  else        { exchange.SetDirection('closesell'); exchange.Buy(-1, amount); }
  _G(maxProfitKey, null); _G(slKey, null); _G(tpDrawKey, null);
}

Der Trailing-Stop lässt Gewinne laufen, während fester Take-Profit und Stop-Loss die Basis sichern. Alle drei Mechanismen sind aktiv – der zuerst ausgelöste entscheidet.

Praktische Laufzeitergebnisse

Nach dem Start der Strategie zeigt das Dashboard in Echtzeit vier Status-Tabellen an: Kontoübersicht mit Laufzeit, aktuellem Eigenkapital und Gesamtrendite; Verfolgungsliste mit Status, Countdown bis zum Listing und Anzahl der Analysen für jede überwachte Coin; KI-Analyse-Zusammenfassung mit der jeweils aktuellsten vollständigen Analyseergebnisse; Echtzeit-Positionsüberwachung mit unrealisierten Gewinnen/Verlusten, maximalem Gewinn und aktiviertem Trailing-Stop, sowie der Option, manuell zu schließen und Stop-Parameter anzupassen.

Am Beispiel von EWYUSDT, das demnächst gelistet wird: Das System hat seit der Entdeckung durch die Ankündigung bereits mehrere Analysen durchgeführt. Jedes Mal gab die KI die Richtung „Long“ an, der Trend wurde als „kontinuierlich verstärkend“ markiert – hier zeigt sich der Effekt des historischen Gedächtnisses: Mehrere Analysen mit gleicher Richtung deuten auf ein stabiles Long-Signal hin, nicht auf eine Fehlinterpretation aufgrund einmaliger Daten. Die jüngste Gesamtbewertung: Die Funding Rates von OKX und HTX sind stabil positiv, die Nachrichtenlage zum bevorstehenden Listing des Korea-ETF-Perpetuals ist insgesamt positiv. Die KI empfiehlt Long mit einer Konfidenz von 76 %, empfohlen wird ein sofortiger Einstieg bei Eröffnung im Bereich von 128 bis 130, 10-facher Hebel, Stop-Loss 5 %, Take-Profit 15 %, mittleres Risiko.

Strategiegrenzen und Risikohinweise

Die Kernlösung dieser Strategie besteht darin, vor dem Listing einer neuen Coin systematisch und automatisiert ein Verständnis für diese Coin aufzubauen – anstatt es manuell zu tun – und die Schlussfolgerungen in handelbare Einstiegssignale umzusetzen. Allerdings müssen ihre Grenzen klar erkannt werden:

Neue Coins sind extrem volatil; der Stop-Loss kann bereits in der ersten Minute nach der Eröffnung ausgelöst werden. Die Qualität der KI-Analyse hängt von der Vollständigkeit der Daten ab; je weniger Daten vor dem Listing, desto konservativer die Analyse. Hebelwirkung verstärkt Gewinne und Verluste; keine Strategie kann stabile Gewinne garantieren.

Die Positionskontrolle ist die wichtigste Voraussetzung für den Einsatz dieser Strategie.

Dieses System ist derzeit eher ein Ausgangspunkt. Das Thema „New Listings“ ist ein tiefgehendes Feld mit vielen Signaldimensionen, Einstiegszeitpunkten und Details des Positionsmanagements, das noch erhebliches Optimierungspotenzial bietet. Wenn Sie eigene Erfahrungen und Erkenntnisse im Bereich New Listings haben, teilen Sie diese bitte in den Kommentaren – nur durch gemeinsamen Austausch kommen wir weiter. Jede Strategie birgt Verlustrisiken; passen Sie die Strategielogik vor dem Einsatz unbedingt an Ihre eigene Situation an.

Strategie-Quellcode: Binance New Listing AI-Strategie