[TOC]

The concept of “new listing trading” is familiar to anyone in the stock market — get in early, grab your allocation, and ride the price discovery when the ticker goes live. The core logic is the same in crypto, except the opportunities come far more frequently. Major centralized exchanges list new perpetual futures contracts every few days, and these opportunities are open to everyone equally.

In the early hours after a contract goes live, the market hasn’t fully priced in the asset. Price elasticity is extreme, and moves far larger than typical price action can unfold in a very short time. If you can call the direction in advance and enter at the moment of launch, that’s exactly where the opportunity lies in perpetual futures new listings.

But here’s the problem — before a new contract goes live, we know almost nothing about the token. Team background, tokenomics, market sentiment, funding rates… all of this requires significant time to collect and analyze. Entering without sufficient understanding is no different from gambling. And trying to manually research every new listing? There’s simply no way to keep up.

That’s why the workflow introduced today was built to solve exactly this problem — the system automatically begins collecting data and running continuous AI analysis the moment an announcement is published, building a solid knowledge base before the token goes live. The entire workflow runs ²⁴⁄₇ autonomously. No manual monitoring needed. Announcement detection, data collection, AI analysis, and market entry — all fully automated.

Overall Architecture: Two Parallel Pipelines

This strategy’s architecture is split into two pipelines.

The Analysis Pipeline runs in loops at longer intervals, continuously monitoring new listing announcements, collecting multi-dimensional data, calling AI for analysis, and accumulating each analysis conclusion into a historical record. The Execution Pipeline runs in rapid high-frequency loops, responsible for real-time detection of whether new tokens have gone live on the exchange. Once a listing is detected, it immediately reads the analysis results, decides whether to enter, and continuously monitors positions for take-profit and stop-loss.

The two pipelines have clear separation of duties — the Analysis Pipeline provides direction, and the Execution Pipeline handles execution.

Analysis Pipeline: Step 1 — Discover New Tokens, Build Tracking Queue

When the Analysis Pipeline starts, it first initializes global state, recording initial capital, run count, and other baseline data:

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

It then fetches Binance’s official announcements to identify upcoming perpetual futures listings:

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' } }
);

Once a new token is identified, the system pushes it into the tracking queue with a status tag: before launch it’s PRE_LISTING (pre-tracking), on launch day it switches to LAUNCH_DAY, after entry it moves to TRADING, and upon completion it’s marked DONE and automatically cleared from the queue.

trackingList.push({
    symbol,
    launchDate,
    status: isLaunchDay ? 'LAUNCH_DAY' : 'PRE_LISTING',
    discoveredAt: now.toISOString(),
    hoursToLaunch: isLaunchDay ? 'Launching today' : hoursToLaunch,
    analysisCount: 0,
    lastAnalyzedAt: null
});

This way the system always focuses only on targets that are currently valuable, never wasting resources on expired opportunities.

Analysis Pipeline: Step 2 — Multi-Dimensional Data Collection

After discovering a new token, the system immediately begins collecting data from three dimensions.

Fundamental data is fetched via the CoinMarketCap API to obtain the token’s market cap, circulation ratio, CMC ranking, and more:

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
    };
}

Sentiment data is gathered via Brave Search, pulling recent news related to the token’s funding background, team developments, and unlock schedules, using three different keyword combinations:

function fetchBraveNews(coin) {
    const key = $vars.braveKey || '';
    const queries = [
        '"' + coin + '" token funding team',
        '"' + coin + '" vesting unlock schedule',
        '"' + coin + '" binance futures listing'
    ];
    // For each query, call the Brave Search API, filter results matching the coin name, deduplicate and return
}

Market data is collected simultaneously from four exchanges — Bybit, OKX, Gate, and HTX — including funding rates, open interest, spreads, and other key indicators. Taking OKX as an example:

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 failed:', e.message); return null; }
}

Cross-exchange verification effectively avoids bias from any single data source, building a more complete picture of the new token.

Analysis Pipeline: Step 3 — AI Analysis with Historical Memory

This is the most critical design element of the entire workflow.

From announcement to actual launch, there are often several days. During this window, the system repeatedly collects data and calls AI for analysis. The key insight: every analysis passes all previous conclusions to the AI, allowing it to make new assessments building on historical judgments.

Reading history and injecting it into the prompt:

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

function buildHistorySection(history) {
    if (history.length === 0) return '(This is the first analysis for this token, no history available)';
    return history.map(h => {
        const ai = h.aiConclusion;
        return [
            '### Analysis #' + h.order,
            '- Time: ' + h.timestamp + ' | Hours to launch: ' + h.hoursToLaunch + ' | Phase: ' + h.phase,
            '- Conclusion: ' + ai.direction + ', Confidence ' + ai.confidence + '%, Risk ' + ai.riskLevel,
            '- Trend: ' + (ai.trendConsistency || 'Initial'),
            '- Entry timing: ' + (ai.entryTiming || '-'),
            '- Summary: ' + ai.summary
        ].join('\n');
    }).join('\n\n');
}

The AI analysis follows several core principles: when historical direction is consistent, confidence increases with each iteration; when a direction reversal appears, the AI must explicitly state whether it’s a genuine signal or short-term noise; when historical judgments have been indecisive, confidence must remain conservative and not be inflated. The AI ultimately outputs a structured conclusion:

// AI output JSON structure
{
    "order": 3,
    "direction": "Long|Short|Hold",
    "confidence": 76,                    // 0-100 integer
    "trendConsistency": "Initial|Strengthening|Maintaining|Weakening|Reversal",
    "reversalType": "Genuine signal|Short-term noise|null",
    "entryTiming": "immediate|drawdown_N",  // drawdown_5 means wait for 5% pullback
    "priceRange": { "low": 128, "high": 130 },
    "leverage": 10,
    "stopLoss": 5,                        // stop-loss percentage
    "takeProfit": 15,                     // take-profit percentage
    "riskLevel": "High|Medium|Low",
    "riskPoints": ["Risk point 1", "Risk point 2"],
    "keyChanges": "Most significant data changes compared to last analysis",
    "summary": "Comprehensive judgment in 100 words or less"
}

After analysis is complete, the conclusion is stored in the history, and the token’s final strategy is updated for the Execution Pipeline to read:

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

When direction remains consistent, confidence increases with each analysis iteration; when direction reverses, the AI must provide clear reasoning. Judgments accumulated this way are far more reliable than any single independent analysis.

Execution Pipeline: Step 4 — Listing Detection and Safe Entry

The Execution Pipeline runs high-frequency loops, using exchange.GetMarkets() to detect whether a new token has appeared in the exchange’s contract list. Once a listing is detected, it first runs through a safety check:

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

After passing all checks, it executes based on the AI’s recommended entry timing. For immediate entry, it calculates contract quantity and places the order:

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 === 'Long') {
    exchange.SetDirection('buy');
    orderId = exchange.Buy(-1, qty);
} else if (ai.direction === 'Short') {
    exchange.SetDirection('sell');
    orderId = exchange.Sell(-1, qty);
}

If the AI determines the opening premium is too high and recommends waiting for a pullback, the system records the target price and continuously polls:

const targetPrice = ai.direction === 'Long'
    ? 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');

If the target isn’t triggered within 2 hours, the opportunity is considered expired and entry is automatically abandoned.

Execution Pipeline: Step 5 — Position Monitoring and Take-Profit / Stop-Loss

After entry, the Execution Pipeline continuously monitors position status. Take-profit and stop-loss use two mechanisms running in parallel:

const TP_SL = {
    DEFAULT_SL: 10,            // Default stop-loss 10%
    DEFAULT_TP: 25,            // Default fixed take-profit 25%
    TRAILING_TRIGGER: 30,      // Enable trailing TP when unrealized profit reaches 30%
    TRAILING_DRAWDOWN: 8       // Trailing TP triggers on 8% drawdown from peak
};

// Update peak unrealized profit
if (pnlPct / 100 > maxProfit) {
    maxProfit = pnlPct / 100;
    _G(maxProfitKey, maxProfit);
}

// Automatically enable trailing TP when threshold is reached
if (tpDrawdown === 0 && maxPnlPct >= TP_SL.TRAILING_TRIGGER) {
    tpDrawdown = TP_SL.TRAILING_DRAWDOWN;
    _G(tpDrawKey, tpDrawdown);
}

// Check three exit conditions in order — whichever triggers first executes
let closeReason = null;
if (tpDrawdown > 0 && drawdown >= tpDrawdown) closeReason = 'Trailing TP';
if (!closeReason && pnlPct <= -maxSL)          closeReason = 'Stop-loss';
if (!closeReason && pnlPct >= entry.takeProfit) closeReason = 'Fixed TP';

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

Trailing take-profit lets winners run as far as possible, while fixed take-profit and stop-loss guard the floor. All three are active simultaneously — whichever triggers first gets executed.

Live Operation Dashboard

After the strategy starts running, the dashboard displays four real-time status tables: Account Overview shows runtime, current equity, and total return; Tracking Queue shows each monitored token’s status, launch countdown, and analysis count; AI Analysis Summary displays each token’s latest full analysis conclusion; Live Position Monitor shows unrealized P&L, peak profit, trailing TP status, and supports manual position closing and stop-loss parameter adjustments.

Taking the recently launched EWYUSDT as an example, the system discovered it from the announcement and has completed multiple consecutive analyses. Every time, the AI’s direction has been Long, with the trend marked as “Strengthening” — this is precisely the historical memory mechanism at work. Multiple analyses pointing in the same direction indicate that the bullish signal is stable, rather than a misjudgment caused by a single data fluctuation. The latest comprehensive assessment: OKX and HTX funding rates are stable and positive, news related to the Korean ETF perpetual listing is generally positive, and the AI recommends going Long with 76% confidence. Suggested entry at the 128–130 price range at market open, 10x leverage, 5% stop-loss, 15% take-profit, medium risk.

Strategy Boundaries and Risk Disclaimer

The core problem this strategy solves is: before a new token goes live, systematically replacing manual research to build understanding of the token, and converting analytical conclusions into actionable entry signals. However, it’s important to clearly recognize its limitations:

New tokens are inherently extremely volatile — stop-losses may be triggered within the first minute of launch; AI judgment quality depends on data completeness, and with less data available pre-launch, assessments will be more conservative; leverage amplifies both gains and losses, and no strategy can guarantee consistent profitability.

Proper position sizing is the most important prerequisite for using this strategy.

This system is currently more of a starting point. New listing trading is a direction with significant depth — the signal dimensions, entry timing judgments, and position management details all have substantial room for optimization. If you have your own experience and insights in this area, feel free to share in the comments. Collective wisdom will take us further. Every strategy carries the risk of loss — always refine the strategy logic based on your own circumstances before use.

Strategy source code: Binance New Listing Smart AI Strategy