Marubozu Strategy

1. Introduction & Hook

Trading is a game of probabilities, discipline, and edge. Among the arsenal of candlestick patterns, the Marubozu stands out for its clarity and decisiveness. The Marubozu Strategy in Pine Script is not just a pattern recognition tool—it is a robust, actionable approach for traders seeking to capitalize on strong market momentum. In this comprehensive guide, we will dissect the Marubozu Strategy from its market logic to advanced automation, ensuring you have the knowledge to implement, customize, and optimize it across platforms and asset classes.

2. What is Marubozu Strategy?

The Marubozu Strategy is based on the Marubozu candlestick, a bar with no shadows (wicks) on either end. This means the open and close are the high and low of the session, signaling overwhelming buying or selling pressure. In bullish Marubozu, the open is the low and the close is the high; in bearish Marubozu, the open is the high and the close is the low. The strategy leverages these bars to identify strong directional moves and potential trend continuations or reversals.

3. Market Logic Behind the Strategy

The Marubozu candlestick is a visual representation of market conviction. When a Marubozu forms, it means one side (buyers or sellers) dominated the session from start to finish. This often precedes further movement in the same direction, as the imbalance may continue. The strategy seeks to enter trades in the direction of the Marubozu, riding the momentum while managing risk.

4. Mathematical Foundation & Formula

Mathematically, a Marubozu is defined as a candlestick where the open equals the low and the close equals the high (bullish), or the open equals the high and the close equals the low (bearish). In practice, due to market noise, a small tolerance is often allowed.

• Bullish Marubozu: open ≈ low and close ≈ high
• Bearish Marubozu: open ≈ high and close ≈ low

Formula (with tolerance):

// Tolerance as a percentage of range
tolerance = 0.05 // 5%
range = high - low
isBullMarubozu = abs(open - low) <= range * tolerance and abs(close - high) <= range * tolerance
isBearMarubozu = abs(open - high) <= range * tolerance and abs(close - low) <= range * tolerance

5. Step-by-Step Calculation Example

Suppose a candlestick has:

• Open: 100
• High: 110
• Low: 100
• Close: 110

Range = 110 - 100 = 10
Tolerance = 10 * 0.05 = 0.5

• abs(100 - 100) = 0 ≤ 0.5
• abs(110 - 110) = 0 ≤ 0.5

This is a bullish Marubozu. The strategy would signal a long entry.

6. Pine Script Implementation

//@version=6
// Marubozu Strategy Implementation
strategy("Marubozu Strategy", overlay=true)

// Parameters
tolerance = input.float(0.05, title="Tolerance (%)", minval=0.0, maxval=0.2)

// Marubozu Detection
range = high - low
isBullMarubozu = math.abs(open - low) <= range * tolerance and math.abs(close - high) <= range * tolerance
isBearMarubozu = math.abs(open - high) <= range * tolerance and math.abs(close - low) <= range * tolerance

// Plotting
plotshape(isBullMarubozu, style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small, title="Bullish Marubozu")
plotshape(isBearMarubozu, style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small, title="Bearish Marubozu")

// Strategy Logic
if isBullMarubozu
    strategy.entry("Long", strategy.long)
if isBearMarubozu
    strategy.entry("Short", strategy.short)

7. Parameters & Customization in Pine Script

The strategy can be customized with parameters such as tolerance, minimum bar size, and filters for volume or trend. For example:

// Customization Example
minRange = input.float(0.5, title="Minimum Range")
minVolume = input.int(100000, title="Minimum Volume")

isValid = range >= minRange and volume >= minVolume
if isBullMarubozu and isValid
    strategy.entry("Long", strategy.long)
if isBearMarubozu and isValid
    strategy.entry("Short", strategy.short)

8. Python & FastAPI + NoSQL Implementation

For algorithmic traders, implementing the Marubozu Strategy in Python enables integration with data pipelines and APIs. Here is a Python example using FastAPI and a NoSQL (MongoDB) backend:

# marubozu.py
from fastapi import FastAPI
from pydantic import BaseModel
from typing import List
from pymongo import MongoClient

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

class Candle(BaseModel):
    open: float
    high: float
    low: float
    close: float
    volume: float

def is_marubozu(candle, tolerance=0.05):
    rng = candle.high - candle.low
    bull = abs(candle.open - candle.low) <= rng * tolerance and abs(candle.close - candle.high) <= rng * tolerance
    bear = abs(candle.open - candle.high) <= rng * tolerance and abs(candle.close - candle.low) <= rng * tolerance
    return bull, bear

@app.post("/marubozu/")
def detect_marubozu(candles: List[Candle]):
    signals = []
    for c in candles:
        bull, bear = is_marubozu(c)
        signals.append({"bullish": bull, "bearish": bear})
    db.signals.insert_many(signals)
    return signals

9. Node.js / JavaScript Implementation

// marubozu.js
function isMarubozu(candle, tolerance = 0.05) {
  const range = candle.high - candle.low;
  const bull = Math.abs(candle.open - candle.low) <= range * tolerance && Math.abs(candle.close - candle.high) <= range * tolerance;
  const bear = Math.abs(candle.open - candle.high) <= range * tolerance && Math.abs(candle.close - candle.low) <= range * tolerance;
  return { bullish: bull, bearish: bear };
}

// Example usage
const candle = { open: 100, high: 110, low: 100, close: 110 };
console.log(isMarubozu(candle));

10. Backtesting & Performance Insights

Backtesting is crucial for validating the Marubozu Strategy. In Pine Script, use strategy functions to simulate trades. Analyze metrics like win rate, profit factor, and drawdown. For Python, use backtesting libraries such as Backtrader or custom scripts. Always use out-of-sample data to avoid overfitting.

// Pine Script Backtest Example
// Results can be viewed in TradingView's Strategy Tester

11. Risk Management Integration

Risk management is the backbone of any successful strategy. Integrate position sizing, stop-loss, and take-profit mechanisms.

// Pine Script Risk Management Example
risk = input.float(1, title="Risk per Trade (%)")
stopLossPerc = input.float(1.5, title="Stop Loss (%)")
takeProfitPerc = input.float(3, title="Take Profit (%)")

if isBullMarubozu
    strategy.entry("Long", strategy.long, qty_percent=risk)
    strategy.exit("TP/SL", from_entry="Long", stop=close * (1 - stopLossPerc/100), limit=close * (1 + takeProfitPerc/100))
if isBearMarubozu
    strategy.entry("Short", strategy.short, qty_percent=risk)
    strategy.exit("TP/SL", from_entry="Short", stop=close * (1 + stopLossPerc/100), limit=close * (1 - takeProfitPerc/100))

12. Combining with Other Indicators

Enhance the Marubozu Strategy by combining it with indicators like RSI, MACD, or moving averages. This can filter false signals and improve reliability.

// Example: Marubozu + RSI Filter
rsi = ta.rsi(close, 14)
if isBullMarubozu and rsi > 50
    strategy.entry("Long", strategy.long)
if isBearMarubozu and rsi < 50
    strategy.entry("Short", strategy.short)

13. Multi-Timeframe & Multi-Asset Usage

The Marubozu Strategy is versatile. Apply it to different timeframes (1m, 15m, daily) and asset classes (equities, forex, crypto, options). In Pine Script, use request.security() for multi-timeframe analysis.

// Multi-Timeframe Example
htf_close = request.security(syminfo.tickerid, "D", close)
if isBullMarubozu and close > htf_close
    strategy.entry("Long", strategy.long)

14. AI/ML Enhancements

Machine learning can optimize Marubozu parameters or combine it with other features. Feature engineering may include Marubozu frequency, size, and context. Reinforcement learning agents can adjust tolerance or combine signals for optimal returns.

# RL agent pseudocode
state = get_market_state()
action = agent.select_action(state)
reward = execute_trade(action)
agent.learn(state, action, reward)

15. Automation with Playwright/Jest

Automate testing of your strategy scripts using playwright for end-to-end checks or Jest for unit tests.

// Jest unit test example
const { isMarubozu } = require('./marubozu');
test('detects bullish marubozu', () => {
  const candle = { open: 100, high: 110, low: 100, close: 110 };
  expect(isMarubozu(candle).bullish).toBe(true);
});

16. Advanced Variations

Advanced traders may use adaptive tolerance, volume-weighted Marubozu, or combine with volatility filters. Experiment with dynamic thresholds based on ATR or recent volatility to refine entries.

// Adaptive Tolerance Example
atr = ta.atr(14)
adaptiveTol = atr / close
isBullMarubozu = math.abs(open - low) <= range * adaptiveTol and math.abs(close - high) <= range * adaptiveTol

17. Common Pitfalls & Misconceptions

• Assuming every Marubozu leads to a trend: Context matters.
• Ignoring volume: Low-volume Marubozu are less reliable.
• Overfitting parameters: Always validate on out-of-sample data.
• Neglecting risk management: Even high-probability setups can fail.

18. Conclusion & Key Takeaways

The Marubozu Strategy is a powerful, momentum-based approach that can be implemented across platforms and asset classes. Its simplicity is its strength, but success depends on context, risk management, and continuous improvement. Use this guide to build, test, and refine your own Marubozu-based systems for robust trading performance.

Glossary of Key Terms

• Marubozu: A candlestick with no wicks, indicating strong directional momentum.
• Tolerance: Allowed deviation from perfect Marubozu conditions.
• Backtesting: Simulating strategy performance on historical data.
• Risk Management: Techniques to control losses and protect capital.
• Multi-Timeframe Analysis: Using signals from different chart intervals.
• Feature Engineering: Creating new data features for machine learning models.

Comparison Table