Example for converting numeric columns to float64:

for col in ['open', 'high', 'low', 'close', 'volume']:
    if col in df.columns:
        df[col] = df[col].astype(float)

Base class: Strategy. Main methods: initialize() and on_candle(candle, df). Common calls: self.buy, self.sell, self.close_position, self.get_position, self.get_state, self.set_state, self.plot, self.mark.

Inputs expose runtime parameters for indicators/strategies. Examples:

length = input.int(10, title="SMA Period", minval=1)
alpha  = input.float(0.8, title="Smoothing Coefficient", minval=0.0, step=0.1)
use_smooth = input.bool(True, title="Enable Smoothing")
label = input.string("SMA", title="Label")
color_line = input.color("#2962FF", title="Line Color")

Signature: plot_indicator(indicator_name: str, plot_type: str, on_graph: bool, indicator_data: list[tuple], color, line_width). • indicator_name: Display name on the chart. • plot_type: e.g., line, area, histogram. • on_graph: True → overlay on the main price chart; False → dedicated panel. • indicator_data: List of (timestamp, value) tuples. • color: HEX or value provided by input.color. • line_width: Stroke width. Simple SMA example:

length = input.int(10, title="SMA Period", minval=1)
sma = df['close'].rolling(window=length, min_periods=1).mean()
plot_indicator(
    "SMA_" + str(length),
    "line",
    True,
    list(zip(df['timestamp'], sma)),
    color="#0000FF",
    line_width=1
)

You can import other indicators into your strategy from the terminal. Commands: • cls → Clear terminal • help → List commands • time → Show current time • uptime → Show session uptime • import <indicator> → Import specified indicator • list imports → List imported indicators • reset <indicator|imports> → Remove specific or all imports

• Define parameters inside initialize(). • Put candle-by-candle decision logic inside on_candle(candle, df). • Use self.buy(...) to open longs, self.sell(...) to open shorts, and self.close_position(...) to exit. • Use self.get_position(), self.get_state(), and self.set_state() for decision support. • Use self.mark(...) and self.plot(...) to leave visible traces on the chart. • These visual calls are mostly visible during backtests and chart review; in live execution they may not produce a visible output. Skeleton example:

class MyStrategy(Strategy):
    def initialize(self):
        self.fast = self.input.int(20, label="Fast EMA")
        self.slow = self.input.int(50, label="Slow EMA")
        self.risk_pct = self.input.float(25.0, label="Risk %")

    def on_candle(self, candle, df):
        if len(df) < self.slow:
            return

        fast_ema = df["close"].ewm(span=self.fast, adjust=False).mean().iloc[-1]
        slow_ema = df["close"].ewm(span=self.slow, adjust=False).mean().iloc[-1]
        pos = self.get_position()

        self.plot("Fast EMA", fast_ema, color="blue")
        self.plot("Slow EMA", slow_ema, color="orange")

        if pos["status"] == "CLOSED" and fast_ema > slow_ema:
            self.buy(percentage=self.risk_pct)
            self.mark(label="Long", color="green", shape="arrow_up")
        elif pos["status"] == "OPEN" and fast_ema < slow_ema:
            self.close_position()
            self.mark(label="Close", color="red", shape="arrow_down")

If you use leverage, you usually pass it directly in the order call. This is especially relevant for futures strategies. Example:

self.buy(percentage=20, leverage=3.0)

As leverage rises, risk increases sharply. Combine it with smaller sizing and clear exit logic.

TP/SL logic is usually calculated as price levels and passed into the order call. Examples:

entry = float(candle["close"])
take_profit = entry + 50
stop_loss = entry - 30
self.buy(percentage=20, take_profit=take_profit, stop_loss=stop_loss)

tp_pct = self.input.float(2.5, label="TP (%)")
sl_pct = self.input.float(1.0, label="SL (%)")
entry = float(candle["close"])
self.buy(
    percentage=20,
    take_profit=entry * (1 + tp_pct / 100.0),
    stop_loss=entry * (1 - sl_pct / 100.0),
)

In the current model, state is the preferred way to track evolving values such as the previous EMA, the last grid level, counters, or staged risk settings. Example:

last_grid = self.get_state("last_grid", default=None)
if last_grid is None:
    self.set_state("last_grid", -1)

• self.mark(label=..., color=..., shape=..., note=...) places a single marker on the active candle. It is typically used to label entries, exits, or other strategy events. • self.plot(name, value, color=..., panel=...) is used to draw a line or value series on the chart. • These visuals are mainly useful during backtests and chart review; in live execution they may not produce a visible result. Example:

self.plot("Fast EMA", fast_ema, color="blue")
self.plot("Slow EMA", slow_ema, color="orange")
self.mark(label="Long", color="green", shape="arrow_up")
self.mark(label="Exit", color="red", shape="arrow_down", note="EMA break")

• Total return, Max Drawdown, Win/Loss ratio, Profit Factor, Sharpe/Sortino (where applicable) • Trade list (entry/exit timestamps, price, PnL, commission) • Equity curve over time • Synchronized chart with indicators and signal markers

You can archive preferred runs and compare them later. The archive maintains strategy version, parameters, date range, and result metrics.

The New Bot form includes Bot Name, Type (Spot/Futures), API connection, Strategy selection, Period, Minimum Candle Count, Operating Days/Hours, and Multi-Coin list. If “Enter on existing signal” is enabled and the market is in a valid buy zone, the bot will enter without waiting for the next signal.

Provide the amount of historical data your strategy needs. For instance, if you use EMA(200), we recommend 200 candles plus a buffer. If uncertain, you may set 5,000—this may increase warmup time but helps ensure data integrity.

After connecting an API, your current balance is retrieved and you can allocate a total amount to the bot. When multiple coins are added, plan your strategy percentages so total exposure remains within that allocation. If several symbols can enter at the same time, size each entry with total account risk in mind instead of assuming one isolated position. Keep strategy sizing practical so orders do not become too small.

Bots are listed as cards on the main page. Each card displays API name, strategy, period, planned days/hours, tracked symbols, and status (Active/Inactive). The power glyph (green/red) reflects the operational state.

• Run: Executes signals against live data. • Safe Shutdown: Closes all open positions, then stops the bot. Irreversible. • Delete: Removes the bot; does not close open positions. Use only in risk-free states. • Panic button: Upon confirmation, closes all positions across all bots.

Remaining time for rented bots is clearly displayed on the card. At the end of the term, the system closes open positions according to order types and stops the bot automatically—ensuring a safe close without user intervention.

The bot detail view provides a P/L chart (percent), live trades, commission impact, side (BUY/SELL), leverage, quantity, and notional value. “Open Positions” and “Spot/Futures Assets” panels reflect your portfolio in real time. Trade and system events are recorded with timestamps in logs.

The “Panic Button” halts all bots and safely closes open positions during emergencies. As it is irreversible, a second confirmation step is required. This mechanism is designed for risk control during unexpected market volatility or infrastructure incidents.

To transact in the Showcase, you must connect your Phantom wallet. Without a connected wallet, purchasing and renting are not permitted. On first use, users are guided to install Phantom Wallet. After connection, SOL balance checks are performed automatically.

As a developer, you may list your bot for sale or rent. While creating a listing: • Sale Price: Permanent sale price (USD). • Rental Price: Daily rate (USD/day). • Payout Wallet Address: You are solely responsible for entering the correct address. The system does not refund incorrect entries. • Listing Description: Strategy overview, use cases, and risk disclosures. A one-time 1 USD listing fee is collected via Solana. The transaction is approved through Phantom and is irreversible.

All payments and listings are signed with Phantom. Prior to confirmation, users can review the amount, network fee, and estimated SOL value. Once approved, the transaction is written to the blockchain and cannot be rolled back. Any losses due to incorrect approvals or addresses remain solely the user's responsibility.

Showcase entries are listed with sale and rental prices. For each bot, total return, Spot/Futures type, and performance history are displayed. Users can filter by bot name or developer via the search box.

For rentals, the total amount is calculated based on the daily rate and paid via Phantom. When the rental period ends, the bot shuts down automatically and any open positions are safely closed by the system.

Purchased or rented bots can be monitored in real time from the user panel. P/L charts, trade history, open positions, and performance ratios are presented transparently.

• Entering the correct wallet address and verifying Phantom approvals are solely the user's responsibility. • Incorrect addresses or approvals are irreversible; Whaleer assumes no liability. • The performance and risk profile of bots listed in the marketplace are the responsibility of their developers; users must carefully review details before transacting.

To connect, enter the API Key and Secret Key provided by your exchange. After validation, the system checks your balance and account information and activates the connection.

You can list, edit, or delete all API keys you have added. A default API may be pre-selected for convenience on your profile page; however, this is only for ease of use. You can manually select any API when starting your bots.

When an API is deleted, all bots linked to this API are automatically disabled. If there are active bots, they are safely shut down before the key is removed. This operation is irreversible.

A detailed training video explains how to create Binance API keys and connect them to Whaleer. It provides step-by-step guidance to ensure a secure setup.

• Never share your API keys publicly or with third parties. • Grant only the necessary permissions; withdrawal must remain disabled at all times. • Your API keys must be active and valid; revoked keys will prevent bots from operating.

The Enable Reading option is mandatory for all bots to function. This permission only allows viewing balances and market information and does not permit any fund transfers.

Users who wish to trade on the Spot market must enable this permission. It allows the bot to submit buy/sell orders. If you do not intend to use Margin, keep scope limited to Spot.

This permission is required for bots that operate on the Futures market. Without it, futures-based strategies will not run.

Enable this if your bots need to transfer funds between Spot and Futures accounts. Without it, the system cannot transition balances across accounts automatically.

• Enable Withdrawals must remain disabled at all times.

class SmaRsiMacdStrategy(Strategy):
    def initialize(self):
        self.length_sma = self.input.int(50, label="SMA Period")
        self.rsi_len = self.input.int(14, label="RSI Period")
        self.risk_pct = self.input.float(25.0, label="Risk %")

    def on_candle(self, candle, df):
        if len(df) < self.length_sma:
            return

        close = df["close"].astype(float)
        sma = close.rolling(window=self.length_sma, min_periods=1).mean().iloc[-1]

        delta = close.diff()
        gain = delta.clip(lower=0)
        loss = (-delta).clip(lower=0)
        rs = gain.rolling(self.rsi_len, min_periods=self.rsi_len).mean().iloc[-1] / max(loss.rolling(self.rsi_len, min_periods=self.rsi_len).mean().iloc[-1], 1e-10)
        rsi = 100 - (100 / (1 + rs))

        pos = self.get_position()
        if pos["status"] == "CLOSED" and candle["close"] > sma and rsi < 70:
            self.buy(percentage=self.risk_pct)
            self.mark(label="Buy", color="green", shape="arrow_up")
        elif pos["status"] == "OPEN" and rsi > 75:
            self.close_position()
            self.mark(label="Exit", color="red", shape="arrow_down")

This example uses the current class-based strategy flow and event-driven order calls.

class TrendLeverageStrategy(Strategy):
    def initialize(self):
        self.ema_period = self.input.int(200, label="EMA")
        self.base_pct = self.input.float(20.0, label="Base %")

    def on_candle(self, candle, df):
        if len(df) < self.ema_period:
            return

        ema = df["close"].astype(float).ewm(span=self.ema_period, adjust=False).mean().iloc[-1]
        dist = (float(candle["close"]) - ema) / ema if ema else 0.0
        pos = self.get_position()

        if pos["status"] == "CLOSED" and dist > 0.02:
            leverage = 2.0 if dist <= 0.04 else 3.0
            self.buy(percentage=self.base_pct, leverage=leverage)
            self.mark(label="Trend Long", color="green", shape="arrow_up")
        elif pos["status"] == "OPEN" and dist < 0:
            self.close_position()
            self.mark(label="Exit", color="orange", shape="arrow_down")

This example shows the current approach where leverage is passed directly in the order call rather than encoded into a position column.

The current model centers on the Strategy class, initialize(), on_candle(), order methods, and state management. Trade sizing is usually passed with self.buy(percentage=...) or self.sell(percentage=...), while leverage is given through leverage= when needed.

In Whaleer, TP/SL logic is usually passed as price levels in the order call. If you prefer a percentage target, convert it to a price first inside your strategy logic and then use it with parameters such as self.buy(..., take_profit=..., stop_loss=...).

It is a decimal in the range 0–1 (e.g., 0.001 = 0.1%). Align it with your exchange's actual fee schedule for best backtest fidelity.

Consider the window sizes of your indicators (e.g., EMA 200 + buffer). If unsure, using 5,000 as an upper bound is acceptable, noting the potential performance impact.

Because several coins may trigger at the same time, you should choose strategy percentage values so total exposure stays within your intended allocation. Equal sizing is optional; the important part is keeping total risk aligned with your account.

All open positions are automatically closed, and the bot shuts down.