Understanding Confirmation Scores

Confirmation scores are Smart Money API's most powerful feature. They combine multiple signal types (whale movements, funding rates, liquidations, exchange flows, on-chain metrics) into a single confidence metric (0-100%) that indicates signal strength and reliability. This tutorial teaches you how to interpret and use confirmation scores for precise market timing.

Table of Contents

What Are Confirmation Scores?
Signal Components
Interpreting Scores
Score Reliability and Probability
Combining with Technical Analysis
Implementation and Usage
Advanced Scoring Techniques

What Are Confirmation Scores?

Confirmation scores represent the probability that a signal indicates imminent market movement in a specific direction. A 75% confirmation score means there's a 75% chance the signal correctly predicts the next 4-hour candle direction based on historical patterns.

Smart Money API calculates confirmation scores continuously by analyzing:

Current whale wallet activity and positioning
Funding rates and their historical precedent
Open interest changes and liquidation clustering
Exchange inflows/outflows (buy vs sell pressure)
On-chain metrics (miner accumulation, stablecoin flows)
Correlation with recent price moves

Signal Components

Each confirmation score breaks down into weighted sub-components. Understanding the breakdown reveals why the API generated a particular score.

Component Weighting (Example for BTC)

Whale Activity (35%): Position changes by tracked whales
Derivatives Metrics (30%): Funding rates + OI trends
Liquidation Cascade (15%): Concentration risk near price
Exchange Flows (12%): Buy vs sell pressure
On-Chain Metrics (8%): Miner, stablecoin, and exchange behavior

        PYTHON
      

import requests

def get_confirmation_scores(symbol='BTC', limit=10):
    """Fetch confirmation scores with component breakdown"""
    response = requests.get(
        'https://api.smartmoneyapi.com/v1/signals/confirmation-scores',
        params={'symbol': symbol, 'limit': limit},
        headers={'X-API-Key': 'your_api_key'}
    )

    scores = response.json()['data']

    print(f"Confirmation Scores - {symbol}")
    print("=" * 70)

    for score_obj in scores:
        print(f"\nTime: {score_obj['timestamp']}")
        print(f"Overall Score: {score_obj['overall_score']:.1%}")
        print(f"Signal Type: {score_obj['signal_type'].upper()}")

        # Component breakdown
        components = score_obj['components']
        print("\nComponent Breakdown:")
        print(f"  Whale Activity:      {components['whale_activity']:.1%}")
        print(f"  Derivatives:         {components['derivatives']:.1%}")
        print(f"  Liquidations:        {components['liquidations']:.1%}")
        print(f"  Exchange Flows:      {components['exchange_flows']:.1%}")
        print(f"  On-Chain Metrics:    {components['onchain']:.1%}")

        # Actual price movement
        if 'actual_move' in score_obj:
            move = score_obj['actual_move']
            print(f"\nActual Result: {move['direction'].upper()} {move['percent']:.2%}")

scores = get_confirmation_scores('BTC')
      

Interpreting Scores

Different score ranges indicate different confidence levels. Use these ranges to determine trade sizing and position hold duration:

Confidence Ranges

90-100%: EXTREME CONFIDENCE - Signal backed by multiple aligned indicators. Use maximum position size. Historical accuracy >85%.
75-89%: HIGH CONFIDENCE - Strong signal with supporting data. Use 75-100% of planned size. Historical accuracy 75-85%.
60-74%: MODERATE CONFIDENCE - Good signal but some contradicting indicators. Use 50-75% position size. Historical accuracy 60-75%.
40-59%: WEAK CONFIDENCE - Mixed signals. Use 25-50% position size or skip. Historical accuracy 40-60%.
Below 40%: DO NOT TRADE - Signal is unreliable or contradicted. Skip these signals entirely.

Score Reliability and Probability

Smart Money API publishes accuracy statistics for different score ranges. These are based on 2+ years of backtested data:

PYTHON

def analyze_score_reliability():
    """Check historical score accuracy and statistics"""

    # Backtested accuracy by score range
    accuracy_by_range = {
        '90-100%': {'accuracy': 0.86, 'sample_size': 2847},
        '75-89%': {'accuracy': 0.78, 'sample_size': 5932},
        '60-74%': {'accuracy': 0.68, 'sample_size': 8291},
        '40-59%': {'accuracy': 0.52, 'sample_size': 6748},
    }

    print("Historical Accuracy by Score Range (2+ years backtesting)")
    print("=" * 60)

    for score_range, data in accuracy_by_range.items():
        accuracy = data['accuracy']
        samples = data['sample_size']

        print(f"\n{score_range} Score Range:")
        print(f"  Accuracy: {accuracy:.1%}")
        print(f"  Sample Size: {samples:,} signals")

    # Probability calculation
    # If signal is 80% confident and has 78% historical accuracy:
    # P(correct) = 0.80 * 0.78 = 62.4% actual probability

    print("\n\nProbability Calculation Example:")
    print("-" * 60)

    signal_score = 0.80  # 80% confirmation
    historical_accuracy = 0.78  # 78% for this score range

    actual_probability = signal_score * historical_accuracy

    print(f"Signal Confirmation: {signal_score:.1%}")
    print(f"Historical Accuracy: {historical_accuracy:.1%}")
    print(f"Actual Trade Probability: {actual_probability:.1%}")
    print("\nInterpretation: This signal has a 62.4% chance of being correct")
    print("based on similar signals in historical data.")

analyze_score_reliability()
      
    

Combining with Technical Analysis

The best results come from combining confirmation scores with traditional technical analysis. When both align, signal probability increases significantly.

PYTHON

import talib  # For technical analysis

def combined_signal_analysis(symbol='BTC', price_data=None):
    """Combine confirmation scores with technical indicators"""

    api_client = SmartMoneyClient('your_api_key')
    scores = api_client.get_signals()['data'][0]

    # Get technical indicators
    if price_data is None:
        price_data = get_ohlcv_data(symbol, periods=50)

    close = price_data['close']

    # Calculate technical indicators
    rsi = talib.RSI(close, timeperiod=14)[-1]
    macd_line, signal_line, histogram = talib.MACD(close)
    bb_upper, bb_middle, bb_lower = talib.BBANDS(close, timeperiod=20)

    current_price = close[-1]
    bb_upper_curr = bb_upper[-1]
    bb_lower_curr = bb_lower[-1]

    print(f"{symbol} Combined Analysis")
    print("=" * 60)

    # Display confirmation score
    print(f"\nConfirmation Score: {scores['overall_score']:.1%}")
    print(f"Signal Type: {scores['signal_type'].upper()}")

    # Display technical indicators
    print(f"\nTechnical Indicators:")
    print(f"  RSI(14): {rsi:.1f} {'(Overbought)' if rsi > 70 else '(Oversold)' if rsi < 30 else '(Neutral)'}")
    print(f"  Price vs BB: {current_price:.2f}")
    print(f"    Upper Band: {bb_upper_curr:.2f} ({((current_price/bb_upper_curr - 1)*100):+.2f}%)")
    print(f"    Lower Band: {bb_lower_curr:.2f} ({((current_price/bb_lower_curr - 1)*100):+.2f}%)")

    # Combined analysis
    confirmation_signal = scores['signal_type']
    rsi_signal = 'BEARISH' if rsi > 70 else 'BULLISH' if rsi < 30 else 'NEUTRAL'
    bb_signal = 'BEARISH' if current_price > bb_upper_curr else 'BULLISH' if current_price < bb_lower_curr else 'NEUTRAL'

    print(f"\nSignal Alignment:")
    print(f"  Confirmation Score: {confirmation_signal}")
    print(f"  RSI Signal: {rsi_signal}")
    print(f"  Bollinger Band: {bb_signal}")

    # Score alignment
    signals = [confirmation_signal, rsi_signal, bb_signal]
    bullish_count = signals.count('BULLISH')
    bearish_count = signals.count('BEARISH')

    if bullish_count >= 2:
        combined_signal = "STRONG BUY"
        confidence = 0.75 + (bullish_count * 0.05)  # Boost for alignment
    elif bearish_count >= 2:
        combined_signal = "STRONG SELL"
        confidence = 0.75 + (bearish_count * 0.05)
    else:
        combined_signal = "NEUTRAL/MIXED"
        confidence = 0.50

    print(f"\n{'=' * 60}")
    print(f"Combined Signal: {combined_signal}")
    print(f"Adjusted Confidence: {confidence:.1%}")

    if bullish_count == 3 or bearish_count == 3:
        print("✓ ALL SIGNALS ALIGNED - Highest confidence trade")

combined_signal_analysis('BTC')
      
    

Implementation and Usage

Implement confirmation score-based trading with dynamic position sizing and risk management.

JAVASCRIPT

class ConfirmationScoreTrader {
  constructor(apiKey, portfolio) {
    this.apiKey = apiKey;
    this.portfolio = portfolio;
    this.minConfidence = 0.60; // Only trade above 60%
    this.maxPositionSize = 0.10; // 10% of capital per trade
  }

  async executeSignal() {
    const response = await fetch(
      'https://api.smartmoneyapi.com/v1/signals/confirmation-scores',
      {
        headers: { 'X-API-Key': this.apiKey }
      }
    );

    const signals = await response.json();

    for (const signal of signals.data) {
      await this.processSignal(signal);
    }
  }

  processSignal(signal) {
    const { symbol, overall_score, signal_type } = signal;

    // Filter by confidence threshold
    if (overall_score < this.minConfidence) {
      console.log(`Signal skipped: ${symbol} confidence too low (${overall_score:.1%})`);
      return;
    }

    // Calculate position size based on confidence
    const baseSize = this.portfolio.capital * this.maxPositionSize;
    const confidenceMultiplier = overall_score; // 0.60 to 1.00
    const positionSize = baseSize * confidenceMultiplier;

    // Calculate leverage (only for high-confidence signals)
    const leverage = overall_score > 0.85 ? 2.0 : 1.0;

    // Execute trade
    this.executeTrade({
      symbol,
      side: signal_type === 'bullish' ? 'buy' : 'sell',
      size: positionSize,
      leverage,
      confidence: overall_score,
      stopLoss: this.calculateStopLoss(symbol, overall_score)
    });

    console.log(
      `Trade executed: ${symbol} ` +
      `(${overall_score:.1%} confidence, ` +
      `size: ${positionSize}, leverage: ${leverage}x)`
    );
  }

  calculateStopLoss(symbol, confidence) {
    // Tighter stops for high confidence
    // Wider stops for lower confidence
    const baseStopPercent = 0.02; // 2%
    const stopPercent = baseStopPercent * (1 - confidence * 0.5);
    return stopPercent;
  }

  async executeTrade(order) {
    // Connect to exchange API and place order
    // Implementation depends on your exchange
  }
}

// Usage
const trader = new ConfirmationScoreTrader('your_api_key', portfolio);
setInterval(() => trader.executeSignal(), 300000); // Check every 5 min
      
    

Advanced Scoring Techniques

Use advanced techniques to extract maximum value from confirmation scores:

Advanced Strategies

Score Momentum: Track if scores are increasing (signal strengthening) or decreasing (signal weakening)
Component Divergence: When one component disagrees with others, signal may reverse soon
Score Clustering: When multiple symbols have high scores simultaneously, expect strong directional move
Historical Accuracy Adjustment: Use live accuracy data to adjust position sizes dynamically
Multi-Timeframe Confirmation: Combine 1h, 4h, and daily scores for maximum reliability

Pro Strategy: The highest-accuracy trades occur when you see 90%+ confirmation scores on multiple timeframes (1h + 4h + daily) simultaneously, AND technical indicators are aligned, AND whale tracking shows accumulation. This combination historically has >90% accuracy.

For more strategies using confirmation scores, see whale tracking, derivatives analysis, and building trading bots.

Start Trading with Confirmation Scores

Access real-time confirmation scores combining all data sources. Make high-probability trades based on multi-signal intelligence from Smart Money API.

Get Confirmation Scores