Bot for mirroring futures positions (Hyperliquid / Bitget → Binance Futures)

Budget: 8000 UAH Deadline: 7 days

Good day! I created position copy traders for the Binance Futures API using Python — with Telegram notifications, configuration, and deployment on a VPS. The most challenging part here is not the mirroring itself, but the partial closures and averaging: I maintain my own position state and compare it with the exchange on each polling to ensure the ratio doesn't drift. I am ready to start from the Hyperliquid→Binance stage and test with small amounts. Is the size ratio fixed or should it be calculated based on the deposit?

Budget: 8000 UAH Deadline: 5 days

Good day, Vladislav!

I can implement exactly such a Python bot for mirroring positions from Hyperliquid / Bitget to Binance USDT-M Futures, with a phased launch, transfer of source code, and deployment on your VPS.

I have worked with exchange APIs, where critical aspects are not just "open/close order," but correctly maintaining the state of the position: size, direction, averaging, partial exits, re-entries, and protection against duplicate actions during polling. For such a bot, I create logic not "by signal," but through comparing the current state of the source position and the target position on Binance, to accurately reflect the change.

How I will handle partial closure of 30% by the leader:
- the bot reads the previous and current size of the leader's position;
- if the position has decreased by 30%, a proportional decrease of your mirrored position on Binance by the same 30% is executed, taking into account the specified coefficient;
- if averaging was done before, the bot does not "confuse" this with a reversal or full exit, but calculates the exact delta of the size change;
- if after partial closure the leader adds to the position again, the bot will also proportionally add to it on Binance.

What will result:
- mirroring of opening, increasing, partial, and full closures;
- configuration for pairs, coefficients, limits;
- Telegram notifications about trades and errors;
- launch on your VPS + short instruction;
- I will provide you with the source code, you will enter the keys yourself.

I suggest moving exactly according to your stages: first Hyperliquid to Binance with testing on small amounts, after verification — Bitget to Binance.

If you want, I can briefly describe the structure of the bot by modules and how I will organize the safe state of positions between polling cycles in the next message.

🌐 My portfolio with recent cases:
https://mrnko.com
💼 Freelancehunt profile:
Freelancehunt
🤝 I would be happy to discuss the details, answer your questions, and offer an optimal solution for your project. Expand

Budget: 11000 UAH Deadline: 7 days

Hello! I will take it. Your stack is Python + REST/WS exchange APIs + Telegram + deployment on VPS; I processed real-time data on my SaaS (WebSocket, from specs to production).

The key is to mirror the POSITION STATE, not individual trades:
• I maintain my own position model for each symbol (size, average); every 5–10 seconds I calculate the delta between the leader's position and mine, taking into account the coefficient.
• Opening / increasing / partial / full = the difference between target and current size → one order-correction. Partial 30% in the leader → proportional -30% for you, without desynchronization and double trades.
• Protection: min-exchange step, rounding, retries, stop on deviation.
• TG notifications for each trade and error; config (pairs, coefficients, limits); keys are entered by you (Bitget read-only, trading only Binance).

We will start with stage 1 (Hyperliquid→Binance, test on small) — you will see the correctness to scale. Stage 1 ≈ $250, 5–7 days; stepwise through Safe — ok.
— Mykola

Budget: 999 UAH Deadline: 7 days

Mirror bots break not on opening — that's straightforward. They break on partial closures, on the price step differences between exchanges, and on rate limits when the position should already be closed, but the API is still unresponsive. This is the part that needs to be assembled correctly the first time.

I am ready to take on the mirror from Hyperliquid → Bitget → Binance Futures. The logic:
• poll every 5–10 seconds through public APIs (Hyperliquid public + Bitget read-only), without authorized source keys
• event logging: opening / adding / partial closure / full closure
• transfer to Binance USDT-M Futures with position size coefficient (so that fractional lots on the source become whole minimums on Binance)
• Telegram notifications for each action and for errors (rate limit / connection drop / status discrepancies)

Stack — Python + asyncio, ccxt/python-binance for native futures SDK. A separate monitoring thread: if the order is not executed within N seconds — re-synchronize the status, so the mirror always reflects the real state.

I will deploy it on your VPS under Linux. I will add a systemd unit — auto-start after server reboot, logs to a file + rotation. After delivery, I won't disappear — I will help with edits and updates in the future at no additional cost.

Let me know if there are nuances regarding the position size conversion coefficient and pairs (all tickers from sources or a limited list) — and I will prepare a work plan right away. Expand

Budget: 999 UAH Deadline: 1 day

Vladislav, I will create a bot that correctly mirrors Hyperliquid and Bitget in Binance Futures, taking into account openings, selections, partial and full closures. I have experience with API integrations and Python automation. I will handle a partial closure of 30% as a reduction of the target volume on Binance, recalculating the delta and checking the actual position after each cycle. I will add Telegram notifications, configuration, deployment on VPS, and provide the code. Let's discuss the first stage.

Budget: 2000 UAH Deadline: 7 days

Hello, I worked on the Mirror Trading Bot — copying trades from Bybit → Binance Futures for a client, polling every 5 seconds, 200+ trades/day without misses, synchronization accuracy 98%.

Regarding partial closure of 30%: the bot compares the current position size of the leader with the previous state, calculates the delta, and proportionally (considering the coefficient) closes the corresponding part on Binance through a reduceOnly order. The state is saved locally after each polling.

Question: should we mirror the stop losses and take profits of the leader, or just the positions themselves? And are there any restrictions on pairs — only specific ones or all active?

I suggest we get in touch; I will provide you with free technical consultation and we can outline a development plan + I will tell you about my team!

Budget: 17911 UAH Deadline: 5 days

Hello! My experience with exchange APIs is as follows: I don't have a direct production case with Binance/Bitget/Hyperliquid API yet, but I have a strong related background — asynchronous work with REST/WebSocket APIs in real-time (WebRTC/Socket.io signaling hub on Node.js), decoupled architecture with persistent state (Goszakup bot: background daemon + separate executor), handling partial errors without crashing the entire process (Avia data pipeline). Exchange APIs are well-documented and standard in pattern (REST + WS), so onboarding is quick — but I say this honestly, not pretending I have "already done it."
How I handle partial closure of 30% of the position by the leader:
I maintain a local state for each pair (size + direction) from the previous polling. In each polling cycle, I compare the new position of the leader with the previous one. Instead of accumulating deltas (which drift with missed polls), I recalculate the target size on Binance directly: target_size = current_leader_size × coefficient. I close the difference between the target and current size on Binance with an order using reduceOnly=true, to exclude accidental increases or reversals of the position due to rounding errors. If the leader closed at zero — it's a full closure. If the leader reversed direction (from long to short) — I handle it as a full closure + new entry, not as a delta, otherwise the logic breaks on the reversal.
What’s included: config (pairs, coefficient, limits), notifications in Telegram about trades and errors, deployment on your VPS with instructions, the source code is fully transferred to you.
I am ready to start from stage 1 (Hyperliquid→Binance, testing with small amounts), payment in stages through Safe.

Budget: 8000 UAH Deadline: 7 days

Good day!

I have reviewed the specifications. I will implement a bot in Python that will synchronize positions between Hyperliquid and Bitget with Binance USDT-M Futures, supporting opening, adjusting, partial, and full closing of positions.

For handling partial closures, I do not use the "send signal" logic. In each polling cycle, the bot determines the target position size (considering the coefficient), compares it with the actual position on Binance, and only executes the necessary difference. This approach works correctly both for closing 30% and for averaging or multiple changes in succession, without accumulating errors.

I will provide:

* configuration of pairs, coefficients, and limits;
* Telegram notifications for all trades and errors;
* API error handling and retries during temporary failures;
* deployment on VPS, Docker (if needed), installation instructions, and complete source code.

I propose to carry out the work in two stages, as specified in the brief: first Hyperliquid → Binance with testing on small amounts, after verification — integration with Bitget.

Preliminary estimate:
💰 8,000 UAH
⏳ 7 days

If there are additional requirements (hedge/one-way mode, TP/SL, or copying only market positions), we can discuss them before starting the work. Expand

Budget: 5000 UAH Deadline: 7 days

Good day! I understood the technical task: a mirror bot for Hyperliquid positions (public API) + Bitget Futures (read-only) → Binance USDT-M Futures with a size coefficient, polling every 5–10 seconds, Telegram, configuration, deployment on your VPS, code will be provided to you.

Experience with exchange APIs: I have written and maintained trading bots for Binance Futures (orders, positions, signatures, API error handling, deployment on VPS). I will connect Hyperliquid and Bitget using their official APIs at the start of the stages — the mirror logic is common, only the source exchange adapters differ.

How I will handle partial closure of 30% by the leader:
- I maintain the target state: for each pair, I calculate "how much should be on Binance" = leader size × coefficient (taking into account limits from the configuration);
- on each polling, I compare the target with the actual position on Binance;
- if the leader has reduced the position by 30% — the target drops by 30%, the bot closes exactly the difference on Binance (reduce-only), rather than reopening from scratch;
- averaging/increasing — conversely, it adds volume to the new target;
- complete closure of the leader → target 0 → complete closure on Binance;
- idempotency: repeated polling does not duplicate the order if already at the target (with allowance/minimum step of the exchange).

I will do it step by step as you request: (1) Hyperliquid→Binance with small amounts; (2) Bitget→Binance. Telegram: transactions + errors. Keys will only be in your .env. Delivery of the stage: code + deployment instructions on VPS + testing.

Please clarify for evaluation:
1) one Binance account for both sources or separation;
2) only hedge/one-way, fixed leverage or copy;
3) what to do in case of discrepancies (missed orders/liquidity) — catch up to the target or alert and stop. Expand

Budget: 10000 UAH Deadline: 7 days

Hello! The task is completely clear. I have experience in developing asynchronous services in Python and integrating with external REST APIs. I will write a reliable and fast bot taking into account all the risks of working with the futures API.

Immediately regarding your key question — how to correctly handle partial closure of 30%:
Here, one cannot rely on the calculation of "delta" between transactions, because in the event of a network failure or API timeout, the error will accumulate, and positions will become desynchronized.

I will implement the Target State Alignment approach (State Reconciliation):
In each polling cycle (5 seconds), the bot takes the net current volume of the leader's position on Hyperliquid/Bitget.
Calculates the target volume for Binance: Target = LeaderSize * Coefficient.
Compares it with your actual volume on Binance and places an order solely for the difference (with the flag reduceOnly=True for closures, to avoid accidentally reversing the position).
An important nuance: I handle rounding steps (stepSize) and the minimum order size (minQty) on Binance. If 30% of the leader's position after multiplying by the coefficient becomes less than Binance's limit — the bot will not throw an error, but will hold the position until the next step or round to the minimum allowed lot.

Technical implementation details:
Stack: Python (asynchronous httpx / asyncio for non-blocking parallel polling), aiogram 3.x for instant notifications in Telegram (successful trades, critical errors, balance).
Resilience: API error handling (Rate Limits, Cloudflare checks, timeouts) through retries.
Security: Configuration via .env file. Your API keys are stored locally on your VPS, the bot does not have access to withdraw funds (only trading and reading).

I am ready to break the project into two Safes:
Hyperliquid → Binance + Telegram notifications + tests with small amounts.
Integration Bitget → Binance + final deployment on your VPS and instructions.
Let's discuss the details in private messages, I am ready to start! Expand

Budget: 1000 UAH Deadline: 1 day

Hello, I am ready to implement a bot for mirroring futures positions. I have relevant experience working with exchange APIs, trading logic, real-time/polling systems, position handling, and automation through Telegram. For Binance, it is correct to use REST for position status and, if necessary, supplement this with the user data stream, as the exchange itself recommends obtaining the current status through position/account endpoints and updating it with account events. Partial closure of 30% by the leader would be handled not as a "buy/sell signal," but as a change in the target position size. The bot compares the current position size of the leader with the current position size on Binance after applying the coefficient, then fills the difference with a market or limit order according to the specified rules. This approach correctly handles opening, topping up, partial reduction, full closure, and averaging without breaking the logic. I will be able to provide an accurate estimate of the timeline and budget after clarifying the list of pairs, hedge/one-way mode on Binance, and requirements for order types.

Budget: 10000 UAH Deadline: 7 days

Bot for mirroring positions on Binance Futures (Python)

I need a bot that reads my positions on Hyperliquid (public API) and Bitget Futures (my read-only key) and proportionally replicates them on my Binance USDT-M Futures via API.

Logic: opening, increasing, partial closing, full closing — everything is mirrored with a customizable size ratio. Polling every 5–10 seconds. Correct handling of partial closures and averaging is mandatory.

Requirements: notifications in Telegram about trades and errors; config (pairs, ratio, limits); deployment on my VPS + instructions; source code is handed over to me. I will enter the keys myself.

Stages: 1) Hyperliquid→Binance, test with small amounts; 2) Bitget→Binance. Payment through safe in stages.

In your response, indicate your experience with exchange APIs and how you will handle a partial closure of 30% of the position by the leader. Expand

Budget: 10000 UAH Deadline: 7 days

Good day. Right away on your key question — partial closure of 30% by the leader, as this is where such bots fail. I wouldn't base the logic on "deal events" (there are no webhooks for other positions — only polling). A robust approach is reconciliation based on the target state, not reproducing individual actions:
At each polling, the bot calculates the desired position size on Binance = leader's position size × coefficient. Then it compares this with the current position on Binance and places an order only for the difference. That is:
— the leader partially closed 30% → desired size fell by 30% → the bot places a reduce-only order for 30% of the mirrored position;
— averaging (increasing) → desired increased → the bot adds;
— full closure → desired = 0 → closes everything.
The logic is the same for all cases, and importantly — it self-recovers: if one polling is missed, the next reconciliation still brings the position to the target, without duplication and drift. Closure is only reduce-only, to avoid accidentally reversing the position.
I definitely take into account what causes such bots to fail: different lot sizes and minimum order sizes on exchanges (30% of a small position may be below Binance's minimum — I handle this separately), rounding to the step, and the case when an order is not executed (the next polling brings it to the target).
Honestly about my experience: I haven't worked on exchange trading bots in production — I won't claim that. But this is a task of integrating REST/WebSocket API + state synchronization + Telegram notifications + deployment on VPS — this is my main work (bots, API integrations, backend in Go/Python). I will gather and test all the logic on the Binance/Bitget testnet before any real funds.
I work step by step, as you laid out: stage 1 — Hyperliquid→Binance, testing with small amounts through safe; stage 2 — adding Bitget→Binance (mainly reusing the core). I will provide you with the code, config (pairs, coefficient, limits), and deployment instructions; you will enter the keys yourself.
Two clarifications for an accurate estimate: which pairs at the start and whether protective limits are needed (max size/slippage), so the bot does not mirror anomalies. After that, I will name the cost for each stage.

Budget: 15000 UAH Deadline: 11 days

Good day! I have experience working with REST/WebSocket API of Binance Futures, Bitget, and Hyperliquid (orders, positions, streams for minimizing latency).

Mirroring logic:
the bot maintains a local state of the leader's position (size, side, average entry price) and compares the current size with the previous one at each polling:

Increase → market/limit order for the increase × coefficient.
Partial closure (e.g., 30%) → I calculate the delta (was_size - new_size), send a reduceOnly order for the corresponding portion × coefficient on Binance, rounding down to the exchange's stepSize/minQty.
Protection against duplication through zascanning on 2 consecutive attempts.
Full closure → reduceOnly order for the entire remainder.
Averaging (adding to the position at a different price) is treated as a regular increase, the average price on Binance is formed naturally through market orders.

Everything is logged, critical actions (opening/closing/order error) are instantly sent to Telegram.
I am ready to start from the Hyperliquid→Binance stage with small amounts, payment in stages through Safe — that works for me. Expand

Budget: 15000 UAH Deadline: 10 days

Good day! We have experience in developing high-load trading systems in Python. We implement this through asynchronous processing of WebSocket streams to minimize delays in order copying. We will ensure correct calculation of proportions and API error handling for stable operation of the Hyperliquid/Bitget integration with Binance.

Budget: 12000 UAH Deadline: 10 days

I do not have direct experience with exchange APIs (Hyperliquid/Bitget/Binance), but I do have experience building integrations with external REST/WebSocket APIs, handling states and queues, as well as deploying and maintaining production services on VPS (Django/Node.js stack). For this task, the key is not "knowledge of a specific exchange," but the correct architecture of the state machine and handling edge cases, so I am ready to describe my approach in detail below.

How I will handle a partial close of 30% of the leader's position:
The bot keeps track of last_known_size for each leader position. On each polling, I compare the new size with the previous one. If the size has decreased, this is a partial close, and the delta = difference (not the entire position again). I multiply the delta by a coefficient, round it according to stepSize/minQty of Binance, and send an order with reduceOnly=true specifically for this delta. This is important: recalculating "from scratch" each time accumulates rounding errors with several consecutive partial closes. In averaging (increasing the position at a different price), separate logic is not needed — Binance will recalculate the average entry price itself; I just add the delta of the volume.

I propose the following plan:
Stage 1 — Hyperliquid → Binance:
Polling the public API of Hyperliquid (5–10 seconds, configurable interval)
State machine: open / increase / partial close / full close / reversal
Module for calculating size with coefficient + rounding to Binance lots
Sending orders to Binance USDT-M Futures (market, reduceOnly for closes)
Telegram notifications about trades and errors
Config file (pairs, coefficient, limits)
Testing with small amounts, deployment on VPS via systemd + instructions
Stage 2 — I will add Bitget (read-only key), the same engine, separate config profile.
Payment in stages through Safe — acceptable.
Estimated duration of stage 1: 1.5–2 weeks considering testing with small amounts. I am ready to discuss details (hedge/net positions on each exchange, limits on order size, behavior during connection interruptions). Expand

Budget: 1234 UAH Deadline: 1 day

Hello! I have experience with Python and developing trading bots (exchange APIs, automation). I would be happy to help you!

Budget: 8000 UAH Deadline: 7 days

Task: synchronize positions from two sources on Binance Futures in real-time, including all types of changes.

I implement it by polling the Hyperliquid public API and Bitget read-only every 5 seconds, storing a snapshot of positions in memory. With each tick, I compare the delta for each symbol and calculate the target size on Binance considering the coefficient. Partial closure of 30% by the leader: the bot sees a decrease in qty, calculates the difference, and places a REDUCE_ONLY market order for the proportional part of its position. Averaging (increasing qty) is handled symmetrically. Telegram notifications via aiogram or httpx, configuration through .env + YAML. Deployment on VPS via systemd service, with instructions.

How many pairs do you plan to mirror simultaneously, and do you need support for cross/isolated margin separately for each pair?

Budget: 27000 UAH Deadline: 7 days

Hello! I have already implemented similar bots for mirroring positions between different exchanges, so I am well aware of the nuances of Binance Futures, Hyperliquid, and Bitget: different position formats, rounding, minimum volumes, partial closures, averaging, and state synchronization.

I will create a bot in Python with a customizable coefficient, limits, Telegram notifications, error handling, and deployment on your VPS. I will provide the source code and instructions, and you will enter the keys yourself.

Budget: 15000 UAH Deadline: 5 days

Hello! I have extensive experience working with cryptocurrency exchange APIs (Binance, Bybit, Bitget, Hyperliquid) and developing trading bots in Python. I will implement the mirroring logic via WebSocket or optimized polling (5-10 seconds), as you requested.

Regarding your question about partial closure (for example, 30%): the bot will monitor the change in position size on the master account. Upon receiving an update via the API, the bot will compare the current state with the local cache and calculate the delta. If the position has decreased by 30%, the bot will send an order to close 30% of the volume on Binance (via a market order for speed or limit if needed). This will ensure synchronization even with complex averaging.

Stack: Python, CCXT (or native APIs for Hyperliquid), Telebot for notifications. The code will be structured, with a separate configuration file and error handling (retries, logging). I am ready to assist with deployment on your VPS.

I am ready to discuss the details, feel free to write.

Budget: 1000 UAH Deadline: 1 day

Good day, I am ready to complete your task quickly and efficiently. I have extensive experience in creating various bots. Please write to me in private messages to discuss the details. I would be happy to help :)