Forem: Alex

🚀 JT-Trader Update!

Alex — Mon, 22 Sep 2025 07:37:49 +0000

🚀 JT-Trader Update!

We’ve made strategy testing even closer to real trading:
🔹 tests in the tester now run synchronized with exchanges — all numbers match exactly what you’ll see on your live account;
🔹 commissions, spreads, contract sizes, as well as minimum and maximum values for opening positions are all taken into account.

⚡️ We’ve also simplified working with assets:
just list the coins separated by commas, and the system will automatically pair them with USDT and launch the multi-tester.

📈 Tests are now more accurate, and launching strategies is easier than ever!

👉 Try it yourself right now: https://jt-lab.com/en

TradingBots

We’ve made working with JT-Trader even easier — meet the Launcher!

Alex — Fri, 19 Sep 2025 05:51:53 +0000

🚀 We’ve made working with JT-Trader even easier — meet the Launcher!

Launcher is the fastest and most convenient way to install JT-Trader.
It automatically downloads all the required components, configures the environment, and launches the application — so you can start trading right away.

🔑 Advantages of the Launcher:
✅ Automatic installation of all dependencies.
✅ Pre-configured environment setup.
✅ Automatic updates.
✅ Simple management interface.
✅ Built-in diagnostics for issues.
📖 The installation guide is as straightforward as possible and available here:
👉 Install via Launcher - https://docs.jt-lab.com/installation/

We’ve completely revamped our documentation, making it much more user-friendly.

Alex — Thu, 18 Sep 2025 11:10:17 +0000

We’ve completely revamped our documentation, making it much more user-friendly.
Now you’ll find:

🔻 a structured navigation menu across all sections;

🔻 faster access to the information you need;

🔻 a clean interface with logical structure;

🔻 new examples and extended function descriptions.

The documentation is no longer just a reference — it’s a full-featured tool for working with the platform.

📖 Check out the updated version here: https://docs.jt-lab.com/

JT-Trader: A Complete Overview of the Cryptocurrency Algorithmic Trading Platform

Alex — Wed, 17 Sep 2025 08:38:37 +0000

What is JT-Trader?

JT-Trader is an open-source platform designed to automate cryptocurrency trading. At its core lies JT-Lib, a library that powers the development, testing, and deployment of trading strategies on real exchanges.

In practice, JT-Trader is a full-featured tool for algorithmic trading:

Developers can build their own strategies in TypeScript.

Traders can use ready-made bots via a user-friendly web interface.

The built-in strategy tester allows you to check whether your algorithm is viable before going live.

How Trading Bots Are Created

Bot development in JT-Trader revolves around the Script class, which extends BaseScript. This class defines all the key lifecycle methods: initialization, data processing, order management, and shutdown.
Bot parameters are defined in static definedArgs. These may include:
position size;
stop-loss and take-profit levels;
indicator periods;
trading pairs, etc.

This approach makes it possible to adjust settings directly from the interface without rewriting code.
Before running a bot in real trading, every strategy can (and should) be backtested — a crucial step for finding effective parameters and avoiding costly mistakes.

Bot Lifecycle

Every trading script in JT-Trader follows a clear lifecycle:
onInit() — load parameters, connect indicators, initialize orders.
onTick() — process live market data and make decisions.
onOrderChange() — react to order executions and status changes.
onStop() — safely shut down and release resources.

Example: A Simple RSI Strategy

Below is a code snippet showing a trading bot based on the RSI indicator, with automatic stop-loss and take-profit handling:

class Script extends BaseScript {
  static definedArgs = [ // User-defined strategy parameters
    { key: 'symbols', defaultValue: 'BTC/USDT:USDT' }, // Trading pair
    { key: 'sizeUsd', defaultValue: 100 }, // Position size in USD
    { key: 'slPercent', defaultValue: 2 }, // Stop-loss percentage
    { key: 'tpPercent', defaultValue: 4 } // Take-profit percentage
  ];

  private basket: OrdersBasket; // Order manager
  private rsi: RelativeStrengthIndex; // RSI indicator
  private sizeUsd: number;
  private slPercent: number;
  private tpPercent: number;

  async onInit() { // Initialization at startup
    this.sizeUsd = getArgNumber('sizeUsd', 100); // Load parameters
    this.slPercent = getArgNumber('slPercent', 2);
    this.tpPercent = getArgNumber('tpPercent', 4);

    this.basket = new OrdersBasket({ // Create order manager
      symbol: this.symbols[0],
      connectionName: this.connectionName
    });
    await this.basket.init();

    this.rsi = await globals.indicators.rsi(this.symbols[0], '1h', 14); // Initialize RSI
  }

  private async signal(): Promise<number> { // Trading signal logic
    const longPosition = await this.basket.getPositionBySide('long');
    if (longPosition.contracts !== 0) return 0; // If there’s already a position – don’t trade

    const rsiValue = this.rsi.getValue();
    if (rsiValue < 30) return 1; // RSI < 30 → buy signal
    if (rsiValue > 70) return -1; // RSI > 70 → sell signal
    return 0; // No signal
  }

  async onTick() { // Called on each price tick
    const currentPrice = close(); // Current closing price
    const signalValue = await this.signal();

    if (signalValue === 1) { // Buy signal
      const contracts = this.basket.getContractsAmount(this.sizeUsd, currentPrice); // Convert USD to contracts
      const stopLoss = currentPrice * (1 - this.slPercent / 100); // Stop-loss price
      const takeProfit = currentPrice * (1 + this.tpPercent / 100); // Take-profit price
      await this.basket.buyMarket(contracts, takeProfit, stopLoss); // Buy with automatic stops
    }

    if (signalValue === -1) { // Sell signal
      const longPosition = await this.basket.getPositionBySide('long');
      if (longPosition.contracts > 0) { // If there’s an open long position
        const contracts = longPosition.contracts;
        const stopLoss = currentPrice * (1 + this.slPercent / 100); // Stop-loss for short
        const takeProfit = currentPrice * (1 - this.tpPercent / 100); // Take-profit for short
        await this.basket.sellMarket(contracts, takeProfit, stopLoss); // Sell with automatic stops
      }
    }
  }

  async onOrderChange(order: Order) { // Handle order status changes
    if (order.status === 'closed') { // If the order has been executed
      log('Script', 'Order executed', { orderId: order.id, side: order.side }, true); // Log the event
    }
  }

  async onStop() { // Cleanup on shutdown
    await this.basket.cancelAllOrders(); // Cancel all active orders
  }
}

Strategy Testing

One of JT-Trader’s biggest strengths is its built-in strategy tester. It allows you to simulate trading strategies on historical data while accounting for commissions, spreads, and slippage.

You can configure:
the testing period,
initial balance,
trading pairs,
timeframes.
The tester outputs:
equity curve charts,
maximum drawdown,
Sharpe ratio,
trade statistics.

A standout feature is parameter optimization — JT-Trader can iterate through thousands of parameter combinations to find the most profitable ones.

Running Bots in Real Time

For live trading, JT-Trader uses the Runtime section of the web interface. Users simply select a strategy file, exchange connection, and trading pairs.

Once launched, the bot streams data via WebSocket, processes every tick, and places orders based on the strategy’s logic.
Key features include:
adjusting parameters on the fly (without restarting),
detailed statistics available in the interface,
utomatic recovery after errors or crashes.

Monitoring and Debugging

JT-Trader comes with a comprehensive logging and reporting system:
all bot actions are logged,
logs can be filtered by type and severity,
Telegram alerts are available for critical issues or trade events.
For developers, there’s also a real-time debug system to inspect indicators, positions, and variables directly while the bot is running. This makes debugging and optimization much more efficient.

Conclusion

JT-Trader is a flexible and open platform for algorithmic crypto trading that combines:
a straightforward strategy development process,
built-in backtesting,
safe 24/7 execution of trading bots,
advanced monitoring and debugging tools.

It’s equally valuable for seasoned algo-traders and beginners taking their first steps in trading automation.

Developing Trading Bots: From Idea to Monetization on JT-Lab

Alex — Fri, 04 Apr 2025 10:13:02 +0000

Hello, my name is Alexander, and I am the founder of the JT-Lab project.
JT-Lab is an ecosystem that connects developers and traders, enabling them to create, test, and monetize trading bots.

If you're a developer interested in algorithmic strategies and automated trading, our platform might be the perfect fit for you. JT-Lab provides a comprehensive set of tools for developing and deploying trading algorithms.

On JT-Lab, you can:
✅ Develop trading bots using our in-house library, JT-Lib.
✅ Test strategies on historical data with the Strategy Tester.
✅ Deploy and manage bots with JT-Trader.
✅ Sell trading bots through JT-Store.

The platform supports integration with major cryptocurrency exchanges.

JT-Lib: A Library for Bot Development

JT-Lib is an open-source library designed for building trading bots, providing seamless interaction with exchanges and easy strategy implementation. It offers:

✅ Strict typing using TypeScript to minimize errors.
✅ Flexible order management for precise control.
✅ A trigger and event system to react to market changes.
✅ Data storage to retain bot states between restarts.
✅ A reporting system for real-time performance analysis.
✅ Built-in indicators and candlestick processing.

Key Components of JT-Lib:

🔹 OrdersBasket

Manages exchange orders.
Supports order filtering by strategy.
Implements Stop-Loss and Take-Profit mechanisms.
Provides server-side trigger orders not available on the exchange.

🔹 Triggers

Automatically reacts to price changes, time conditions, or new orders.
Simplifies complex algorithmic strategies.

🔹 Events

Responds to:
New orders.
Candlestick changes.
Incoming trades.
Ideal for multi-currency and event-driven strategies.

🔹 Storage

Saves bot data between restarts.
Restores the last known state upon strategy launch.

🔹 Report

Built-in reporting system.
Displays data in cards, tables, and charts.
Useful for debugging and analyzing live bots.

🔹 Indicators

Provides indicator and candlestick buffer functionality.
Supports custom indicators across multiple timeframes.

With JT-Lib, developers can focus on strategy creation without worrying about low-level exchange interactions. Best Practice | Documentation JT-Lab

Strategy Tester: Backtesting Trading Strategies

The Strategy Tester is designed to assess the effectiveness of trading algorithms under different market conditions. It helps analyze performance, validate strategies, and identify strengths and weaknesses.

🔹 Historical data analysis to evaluate strategies.
🔹 Performance metrics such as profitability, drawdown, and recovery factor.
🔹 Multi-asset testing to assess strategies across various markets.
🔹 Market factor adjustments, considering volatility, liquidity, and fees.
🔹 Order execution modeling, accounting for slippage and delays.

JT-Trader: Trading Bot Management System

JT-Trader is a platform for deploying, monitoring, and managing trading bots with real-time exchange integration.

🔹 Centralized bot management – control multiple strategies across exchanges.
🔹 Interactive interface – start, stop, and modify bot parameters effortlessly.
🔹 Real-time monitoring – track trades, profits, losses, and other key metrics.
🔹 Flexible parameter settings – adjust strategies without rewriting code.
🔹 Automated reporting – generate detailed analytics on bot performance.
🔹 Multi-exchange support – streamline operations across popular platforms.
🔹 Logging & debugging tools – analyze bot behavior and detect potential issues.

Developers can use custom strategies or adapt ready-made solutions from JT-Store to fit their trading needs.

JT-Store: Monetizing Trading Algorithms

JT-Store is a marketplace where developers and experienced traders can sell their strategies.

🔹 Transparent ratings & reviews to help users find reliable bots.
🔹 Trial periods so traders can test bots before purchasing.
🔹 Affiliate programs & promo listings to accelerate monetization.

This allows developers not only to build trading solutions but also to profit from them.

Why Join JT-Lab?

If you're an algorithmic trading developer, JT-Lab offers:

✅ A complete environment for bot development, testing, and deployment.
✅ Flexible development in TypeScript.
✅ Advanced optimization & analytics tools.
✅ Monetization opportunities for your bots.
✅ A community of like-minded traders & developers.

Join JT-Lab and build the best algorithmic trading strategies with us! 🚀