Introduction

Managing cryptocurrency trading positions efficiently can be a daunting task. This blog explains how a Binance futures tracker, integrated with a Telegram bot, simplifies tracking your trading positions in real-time.

What is the Binance Futures Telegram Bot?

This Python-based system connects Binance’s futures trading API with a Telegram bot, offering real-time updates on your open positions. Key functionalities include:

• Fetching live account information from Binance.
• Displaying open trading positions with details like symbol, position amount, and unrealized profit.
• Sending updates directly to your Telegram account for easy access.

How Does It Work?

The bot leverages Binance’s Python SDK and Telegram’s pyTelegramBotAPI library to seamlessly fetch and relay information. Here’s an overview:

1. Initialization: The script initializes a Binance client using API credentials and connects a Telegram bot with its token.
2. Message Handling: Whenever a user sends a message to the bot, it retrieves open trading positions from Binance’s API.
3. Data Filtering: Only active positions with non-zero initial margins and amounts are shown.
4. Real-Time Notifications: The bot sends detailed messages about each position directly to the user via Telegram.

This process ensures that traders can monitor their positions without logging into Binance repeatedly.

Required Setup

To replicate this bot, you’ll need:

1. API Keys:
   • Binance API Key and Secret Key.
   • Telegram Bot Token (obtainable from BotFather).
2. Dependencies: Install the required libraries using pip:

• pip install pyTelegramBotAPI python-binance

• Code Configuration: Replace placeholder values like YOUR_API_KEY, YOUR_SECRET_KEY, and YOUR_BOT_TOKEN with your actual credentials in the script.

Introduction

Are you looking for an automated way to execute crypto trades based on market trends? This Python script leverages a Simple Moving Average (SMA) crossover strategy using the Binance API to automate crypto trading. The system monitors real-time data, calculates SMAs, and places buy/sell orders when predefined conditions are met, optimizing your trading experience. In this guide, we’ll walk through how the system works and how to set up and run the script.

How the System Works

The Python script connects to the Binance API and uses a moving average crossover strategy to make trading decisions. Here’s a breakdown of the key features:

– Binance API Integration: The script uses the Binance API to fetch historical price data and real-time trading information.
– SMA Crossover Strategy: Calculates two SMAs (short-term and long-term) to determine market trends.
– Automated Trading Decisions: Places orders when a short-term SMA crosses a long-term SMA, indicating a market shift.
– Stop-Loss and Profit-Taking Mechanisms: Protects against losses and locks in profits by closing positions based on predefined price limits.

Setting Up the Python Script

To get started, you need to configure and run the script properly. Here’s how:

1. Prerequisites

Ensure you have the required libraries installed. You can install them using:

“`bash
pip install pandas==1.3.0 numpy==1.21.0 python-binance==1.0.16 nest-asyncio==1.5.1
“`
These libraries enable data manipulation (Pandas), numerical calculations (NumPy), and interaction with the Binance API (python-binance).

2. Configure Binance API Keys

Replace the placeholder API keys in the script:

“`python
api_key = “***”  # Your Binance API key
api_secret = “***”  # Your Binance API secret
“`

Understanding the Main Functions

Fetching Historical Data

The script fetches historical price data for the trading pair you specify. This data is used to calculate SMAs:

“`python
def get_historical_data(symbol, LT):
…
“`

**Explanation**: This function retrieves closing prices and calculates both the short-term (ST) and long-term (LT) SMAs using the specified periods.

Calculating Live SMAs

To keep track of real-time price movements, the script calculates live SMAs:
“`python
def live_sma(hist, live):
…
“`

**Explanation**: This function updates the SMA values using live price data, enabling the script to make immediate trading decisions.

Main Trading Logic

The core of the script is the `main` function, which manages the trading logic:
“`python
async def main(coin, qty, sl_limit, open_position=False):
…
“`

This function connects to the Binance WebSocket, monitors live trades, and compares the live SMA values:

– **Open a Position**: If the short-term SMA crosses above the long-term SMA, indicating a price increase, the script opens a buy order.
– **Close a Position**: If the price hits the stop-loss limit or reaches the profit target (e.g., 2% above the buy price), the script closes the order.

Running the Script

To execute the trading bot, run the script with your desired parameters:
“`python
if __name__ == “__main__”:
# Set the trading parameters
coin = ‘DOGEUSDT’  # Trading pair
qty = 1000  # Quantity to trade
sl_limit = 0.11  # Stop-loss limit
…
“`

**Important Notes**:
– **API Key Security**: Never expose your API keys publicly. Always keep them secure.
– **Test Before Using Real Funds**: Consider testing the script with Binance’s test environment or a small amount of capital to verify the logic.

Advantages of Automating Crypto Trading

Automated trading bots, like this one, provide several benefits:
– **24/7 Monitoring**: Bots continuously track the market, allowing you to capitalize on opportunities without needing to monitor manually.
– **Emotionless Trading**: Bots remove emotions from the trading process, adhering strictly to the strategy.
– **Efficiency**: Automation saves time and can execute trades faster than manual intervention.

Enhancements and Optimization Tips

To maximize the bot’s performance, consider these optimizations:
– **Tweak the SMA Periods**: Experiment with different short-term and long-term periods to find the best setup for your chosen trading pair.
– **Implement Risk Management**: Incorporate additional safeguards, such as trailing stop-losses or maximum daily trade limits, to minimize risk.
– **Backtest the Strategy**: Before deploying the bot with real funds, backtest it using historical data to validate its performance.

Conclusion

This Python trading bot provides a solid foundation for anyone looking to automate crypto trading using a simple SMA crossover strategy. By following this guide, you can set up and optimize your bot, enhancing your trading efficiency and potential profitability. Remember to test and tweak your setup for best results!

Links:

Binance API Documentation