Three Black Crows

1. Introduction & Hook

The world of trading is filled with patterns, signals, and strategies. Among these, the Three Black Crows stands out as a powerful bearish reversal pattern. Traders who master its nuances can anticipate market downturns and position themselves for profit. This article dives deep into the Three Black Crows strategy, exploring its origins, logic, mathematical foundation, and practical implementation across Pine Script, Python, Node.js, and more. Whether you are a beginner or a seasoned quant, this comprehensive guide will equip you with the knowledge and tools to leverage this pattern in your trading arsenal.

2. What is Three Black Crows?

The Three Black Crows is a classic candlestick pattern used in technical analysis. It signals a potential reversal from a bullish to a bearish trend. The pattern consists of three consecutive long-bodied bearish candles, each closing lower than the previous one. The open of each candle is typically within the body of the previous candle, and the closes are near the lows, indicating strong selling pressure.

• First Crow: The first bearish candle signals the start of selling pressure.
• Second Crow: The second candle continues the downward momentum, closing lower than the first.
• Third Crow: The third candle confirms the reversal, closing even lower.

This pattern is most significant after a sustained uptrend, as it suggests that the bulls are losing control and bears are taking over.

3. Market Logic Behind the Strategy

The logic behind the Three Black Crows pattern is rooted in market psychology. After a bullish run, the appearance of three strong bearish candles indicates a shift in sentiment. Buyers who were previously in control start to exit their positions, while sellers gain confidence. This transition often leads to further declines as more participants recognize the reversal and act accordingly.

• Exhaustion of Buyers: The uptrend loses steam, and buyers begin to take profits.
• Emergence of Sellers: Sellers step in, pushing prices lower with each candle.
• Confirmation: The third candle confirms the change in trend, attracting more sellers.

Understanding this psychological shift is crucial for traders aiming to capitalize on the pattern.

4. Mathematical Foundation & Formula

While the Three Black Crows is primarily a visual pattern, it can be defined mathematically for algorithmic trading. The key criteria are:

• Three consecutive bearish candles (close < open).
• Each candle opens within the body of the previous candle.
• Each candle closes lower than the previous close.
• Each candle has a relatively long body and small or no lower shadow.

Let C[i] be the close price and O[i] the open price at bar i. The formula for detecting Three Black Crows at bar i is:

Bearish1 = C[i-2] < O[i-2]
Bearish2 = C[i-1] < O[i-1]
Bearish3 = C[i] < O[i]
OpensWithinBody = O[i-1] <= O[i-2] and O[i-1] >= C[i-2] and O[i] <= O[i-1] and O[i] >= C[i-1]
ClosesLower = C[i-1] < C[i-2] and C[i] < C[i-1]
ThreeBlackCrows = Bearish1 and Bearish2 and Bearish3 and OpensWithinBody and ClosesLower

5. Step-by-Step Calculation Example

Let’s walk through a hypothetical example:

• Bar 1: 98 < 100 (bearish)
• Bar 2: 95 < 97 (bearish), 97 within 100-98
• Bar 3: 92 < 94 (bearish), 94 within 97-95
• Closes: 95 < 98, 92 < 95

All conditions are met, so a Three Black Crows pattern is detected at Bar 3.

6. Pine Script Implementation

Pine Script is the scripting language for TradingView. Here’s a robust implementation of the Three Black Crows pattern:

//@version=6
indicator("Three Black Crows Detector", overlay=true)
// Detect bearish candles
bearish1 = close[2] < open[2]
bearish2 = close[1] < open[1]
bearish3 = close < open
// Check if opens are within previous bodies
opensWithinBody = open[1] <= open[2] and open[1] >= close[2] and open <= open[1] and open >= close[1]
// Check if closes are lower
closesLower = close[1] < close[2] and close < close[1]
// Final pattern detection
threeBlackCrows = bearish1 and bearish2 and bearish3 and opensWithinBody and closesLower
// Plot signal
plotshape(threeBlackCrows, style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small, title="Three Black Crows")

This script highlights the pattern directly on your chart, making it easy to spot potential reversals.

7. Parameters & Customization in Pine Script

Customization is key for adapting the strategy to different markets and timeframes. Here’s how you can add parameters:

//@version=6
indicator("Three Black Crows Custom", overlay=true)
bodyPercent = input.int(60, title="Min Body %")
minBody = (high - low) * bodyPercent / 100
bearish1 = close[2] < open[2] and math.abs(close[2] - open[2]) > minBody[2]
bearish2 = close[1] < open[1] and math.abs(close[1] - open[1]) > minBody[1]
bearish3 = close < open and math.abs(close - open) > minBody
opensWithinBody = open[1] <= open[2] and open[1] >= close[2] and open <= open[1] and open >= close[1]
closesLower = close[1] < close[2] and close < close[1]
threeBlackCrows = bearish1 and bearish2 and bearish3 and opensWithinBody and closesLower
plotshape(threeBlackCrows, style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small, title="Three Black Crows")

Adjust bodyPercent to filter out candles with small bodies, reducing false signals.

8. Python & FastAPI + NoSQL Implementation

Algorithmic traders often use Python for backtesting and automation. Here’s a Python function to detect the pattern, plus a FastAPI endpoint and NoSQL (MongoDB) integration:

import pandas as pd
from fastapi import FastAPI, HTTPException
from pymongo import MongoClient

def detect_three_black_crows(df):
    patterns = []
    for i in range(2, len(df)):
        o1, c1 = df['Open'][i-2], df['Close'][i-2]
        o2, c2 = df['Open'][i-1], df['Close'][i-1]
        o3, c3 = df['Open'][i], df['Close'][i]
        if c1 < o1 and c2 < o2 and c3 < o3:
            if o2 <= o1 and o2 >= c1 and o3 <= o2 and o3 >= c2:
                if c2 < c1 and c3 < c2:
                    patterns.append(i)
    return patterns

app = FastAPI()
client = MongoClient('mongodb://localhost:27017/')
db = client['trading']
coll = db['patterns']

@app.post("/detect")
def detect_endpoint(data: dict):
    df = pd.DataFrame(data)
    indices = detect_three_black_crows(df)
    coll.insert_one({"pattern": "Three Black Crows", "indices": indices})
    return {"indices": indices}

This setup allows you to detect the pattern via API and store results in MongoDB for further analysis.

9. Node.js / JavaScript Implementation

For web-based or real-time applications, JavaScript is a popular choice. Here’s a Node.js function to detect the pattern in OHLC arrays:

// Detect Three Black Crows in OHLC arrays
function detectThreeBlackCrows(ohlc) {
  const indices = [];
  for (let i = 2; i < ohlc.length; i++) {
    const [o1, c1] = [ohlc[i-2].open, ohlc[i-2].close];
    const [o2, c2] = [ohlc[i-1].open, ohlc[i-1].close];
    const [o3, c3] = [ohlc[i].open, ohlc[i].close];
    if (c1 < o1 && c2 < o2 && c3 < o3) {
      if (o2 <= o1 && o2 >= c1 && o3 <= o2 && o3 >= c2) {
        if (c2 < c1 && c3 < c2) {
          indices.push(i);
        }
      }
    }
  }
  return indices;
}

This function can be integrated into trading bots or browser-based charting tools.

10. Backtesting & Performance Insights

Backtesting is essential to validate any trading strategy. In Pine Script, you can use the strategy functions to simulate trades:

//@version=6
strategy("Three Black Crows Backtest", overlay=true)
threeBlackCrows = //... (pattern logic as above)
if threeBlackCrows
    strategy.entry("Short", strategy.short)

Analyze metrics such as win rate, profit factor, and drawdown. In Python, use libraries like backtrader or zipline for more advanced simulations. Always test on multiple assets and timeframes to ensure robustness.

11. Risk Management Integration

Risk management is critical. Integrate position sizing, stop-loss, and take-profit mechanisms:

• Position Sizing: Use a fixed percentage of capital per trade.
• Stop-Loss: Place stops above the pattern’s high.
• Take-Profit: Set targets based on ATR or support levels.

//@version=6
strategy("Three Black Crows Risk Mgmt", overlay=true)
stopLoss = high[2] + atr(14)
takeProfit = close - 2 * atr(14)
if threeBlackCrows
    strategy.entry("Short", strategy.short)
    strategy.exit("TP/SL", from_entry="Short", stop=stopLoss, limit=takeProfit)

This approach automates exits and protects your capital.

12. Combining with Other Indicators

Enhance the Three Black Crows strategy by combining it with:

• RSI: Confirm overbought conditions before entering.
• Moving Averages: Trade only below the 200-period MA for stronger signals.
• Volume: Look for increasing volume during the pattern for confirmation.

//@version=6
rsiValue = ta.rsi(close, 14)
ma200 = ta.sma(close, 200)
if threeBlackCrows and rsiValue > 70 and close < ma200
    strategy.entry("Short", strategy.short)

This reduces false positives and improves reliability.

13. Multi-Timeframe & Multi-Asset Usage

The Three Black Crows pattern can be applied across timeframes and asset classes:

• Timeframes: Use on 1m, 15m, daily, or weekly charts. Higher timeframes yield stronger signals.
• Assets: Works on equities, forex, crypto, and even options charts.

//@version=6
higherTF = input.timeframe("D", title="Higher Timeframe")
highTF_crows = request.security(syminfo.tickerid, higherTF, threeBlackCrows)
if highTF_crows
    strategy.entry("Short", strategy.short)

Multi-timeframe analysis increases confidence in the signal.

14. AI/ML Enhancements

Modern trading leverages AI and machine learning. Use the Three Black Crows as a feature in ML models:

• Feature Engineering: Encode pattern occurrences as binary features.
• Reinforcement Learning: Train agents to optimize parameters and exits.

# Example: Feature engineering in pandas
df['three_black_crows'] = 0
indices = detect_three_black_crows(df)
df.loc[indices, 'three_black_crows'] = 1
# Use as input to ML model

AI can help refine entry/exit rules and adapt to changing market conditions.

15. Automation with Playwright/Jest

Automated testing ensures your scripts work as intended. Use playwright for end-to-end browser tests or Jest for unit testing:

// Jest unit test for pattern detection
const { detectThreeBlackCrows } = require('./pattern');
test('detects pattern', () => {
  const ohlc = [
    {open: 100, close: 98},
    {open: 97, close: 95},
    {open: 94, close: 92},
  ];
  expect(detectThreeBlackCrows(ohlc)).toContain(2);
});

This ensures reliability and prevents regressions as you update your codebase.

16. Advanced Variations

Advanced traders may tweak the pattern for better results:

• Body Size Filters: Require larger candle bodies for stronger signals.
• Volume Confirmation: Only signal if volume increases with each candle.
• Hybrid Patterns: Combine with engulfing or doji patterns for added context.

Experiment with these variations to suit your trading style and market conditions.

17. Common Pitfalls & Misconceptions

• False Signals: The pattern can appear in consolidating markets, leading to whipsaws.
• Ignoring Context: Always consider trend, volume, and other indicators.
• Overfitting: Avoid excessive parameter tuning that fits past data but fails in live trading.

Stay disciplined and use robust risk management to mitigate these risks.

18. Conclusion & Key Takeaways

The Three Black Crows is a potent bearish reversal pattern. By understanding its logic, mathematical foundation, and implementation across platforms, traders can harness its power for consistent profits. Combine it with sound risk management and other indicators for best results. Always backtest and adapt to evolving markets.

Glossary of Key Terms

• Bullish/Bearish: Upward/downward market movement.
• Candlestick: Chart representation showing open, high, low, and close.
• Backtesting: Testing a strategy on historical data.
• ATR: Average True Range, a volatility measure.
• Reinforcement Learning: AI technique for optimizing decisions.

Comparison Table