Skip to content
PD
EN RU
Trading & fintech Client: A trader with their own strategy

Anton Trade System - Crypto Copy-Trading Bot

Every trade copies to subscribers' accounts by itself, for a profit share

A copy-trading bot that takes one trader's TradingView signals and mirrors every entry and exit across all subscribers' exchange accounts at once, run and monetized through Telegram.

Before

The trader wanted to earn from their own strategy by letting subscribers follow it. But opening a trade on dozens of other people's accounts within seconds, managing every position and working out the commission by hand is impossible.

What I built

A signal from the strategy on TradingView opens the same trade on each subscriber's Bitget account, with take-profit, averaging and stop-loss. It is run from a Telegram bot and a panel where each subscriber has their own profit share.

After

A trade repeats on every subscriber's account moments after the signal, with no manual clicks, and a position can be closed for everyone with one command. The bot carries out the trader's own strategy; returns are not guaranteed.

What the client got

  • Trade copying

    One strategy signal opens the trade on each subscriber's own Bitget account.

  • Exit for everyone in one command

    One command takes every subscriber out of the position at the same time.

  • Take-profit, averaging, stop-loss

    Profit-taking, adding to a position and loss limits are set for each position.

  • A share of profit

    The commission is set separately for each subscriber.

  • Run from Telegram

    Positions, orders and closing through bot commands, plus close alerts and weekly summaries.

  • A subscriber panel

    Each subscriber's balance, exchange keys and share, open trades and an order history with profit and loss.

How it was built: details and stack

Tech Stack

PythonFastAPIaiogram 3PostgreSQLAsync Worker QueueBitget APITradingView WebhooksAlembicGitHub Actions CI/CDVPS (systemd, Nginx/Caddy)

Overview

Anton Trade System is a crypto copy-trading bot: one trader’s strategy fires a signal, and the system instantly opens the matching position on every subscriber’s own exchange account - then closes them all together when the strategy exits. It’s the machinery that turns one strategy into a service other people can subscribe to. Built in Python, it receives TradingView alerts through a FastAPI webhook, queues them in PostgreSQL, and a dedicated worker places the orders on each user’s Bitget keys, applying take-profit, DCA and stop-loss. Operators run the whole thing from a Telegram bot and an admin dashboard, and take a configured share of each subscriber’s profit.

Problem

A trader with an edge faces a business problem, not a trading one: how to let other people follow the strategy automatically and get paid for it. Doing it manually is impossible - the same entry has to hit dozens of separate exchange accounts within seconds of the signal, each account has its own API keys and settings, take-profit and stop-loss have to be managed per position, and when the strategy says “exit,” every subscriber has to be closed at once. On top of that, the operator needs to track who’s subscribed, hold their keys securely, and calculate a profit-share. That’s a system with a control panel, not a person clicking buttons.

Solution

The bot separates signal intake from order execution so it scales cleanly. TradingView alerts POST to a passphrase-protected FastAPI webhook, which stores the signal in PostgreSQL and enqueues a task. A worker then loops over every subscribed user and mirrors the trade onto that user’s own Bitget keys, with configurable TP / DCA / SL. A single mass-close command exits the position for everyone simultaneously. The operator’s control surface is Telegram: an aiogram 3 bot exposes /positions, /orders and /close, and the system pushes trade-close notifications and weekly performance summaries. An admin dashboard manages subscribers - trading balance, exchange keys, Telegram chat ID and the profit-share % - shows the currently open trades with the avatars of the users holding each one, and keeps a PnL order history. Indicator values are kept honest with a Wilder RSI (RMA) computed exactly as TradingView does, aggregating 15-minute candles into 45-minute closes.

Features

  • Copy-trading fan-out - one signal opens the trade on every subscriber’s own exchange keys at once
  • Telegram bot control - an aiogram bot with /positions, /orders, /close, plus close-notifications and weekly PnL summaries
  • Admin dashboard - subscribers, exchange keys, chat IDs, profit-share %, live trades and order history
  • Per-user profit-share - the operator’s commission configured per subscriber
  • One-click mass close - exit every subscriber’s position on a single command
  • Risk automation - configurable take-profit, DCA and stop-loss per position
  • Durable signal queue - TradingView webhook decoupled from execution so nothing is dropped under load
  • TradingView-accurate RSI - Wilder/RMA indicator parity with the strategy on the chart

Architecture

The system is built around a receive/execute split. An async FastAPI + uvicorn app takes the webhook and writes to PostgreSQL, which holds both the signals and the task queue. A separate worker consumes tasks and does the slow, failure-prone work - exchange calls and Telegram messaging - off the request path, so a sluggish exchange response can never delay signal intake, and failed orders can be retried without losing a signal. The aiogram 3 trade-bot writes its own tasks into the same queue, so Telegram commands and TradingView signals flow through one execution pipeline. Schema changes run through Alembic; in production the app sits on 127.0.0.1 behind Nginx/Caddy so TradingView can POST to a clean portless URL, and it ships via GitHub Actions (CI + SSH deploy to a VPS under systemd --user).

Results

  • The trader’s strategy turned into a subscribable copy-trading service
  • Signals mirrored to all subscriber accounts within moments of firing, hands-free
  • Instant mass-close to exit everyone at once, and per-position TP/DCA/SL
  • Telegram-native operation with live control, close alerts and weekly PnL reports
  • Profit-share monetization and subscriber management via the admin dashboard

What Was Learned

Copy-trading looks like a trading problem but is really a distribution and reliability problem. The strategy is the easy part; the hard part is guaranteeing that one signal reaches many accounts fast, that a slow or failing exchange call for one subscriber never blocks the others, and that “close everyone now” is truly atomic from the operator’s point of view. Routing everything - both TradingView signals and Telegram commands - through a single durable queue and a retrying worker is what makes that dependable. And matching TradingView’s RSI math exactly (Wilder’s RMA plus correct candle aggregation) is the small, unglamorous detail that keeps the operator’s numbers and the chart in agreement - which, when other people’s money is riding on the signals, is the difference between a service and a liability.

Services used in this project

Related case studies

Need a similar system?

Tell me about your challenge - I will propose an architecture and the shortest path to a working product.