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

Budget: 18000 UAH Deadline: 12 days

Good day!

The topic is interesting; I have worked with exchange APIs - both with Binance Futures and the public Hyperliquid. I also understand the specifics of read-only keys on Bitget. In general, everything is clear; polling every 5-10 seconds is quite a workable option. Regarding partial closure of 30% - the bot maintains a local state for each leader's position, compares the new size with the previous one, and closes a proportional share on my account considering the coefficient. I process averaging separately to avoid confusion with top-ups. Staged payment through safe suits me completely; we will start with Hyperliquid and testing with small amounts.

I look forward to collaborating.
Best regards,
Andriy Voznyak

Budget: 15000 UAH Deadline: 10 days

Good day.

The categories of Python and bot development are indicated absolutely correctly. This is an ideal stack for creating reliable trading algorithms.

I am ready to develop a fast bot for you to mirror positions from Hyperliquid and Bitget on Binance USDT M Futures. I have a good understanding of the specifics of working with cryptocurrency API of futures markets and the importance of precise state synchronization.

I will answer your main question regarding the partial closure of the leader's position by 30 percent: During each polling cycle every 5 or 10 seconds, the bot compares the current size of the leader's position with the previously saved state. If the algorithm detects a decrease in the leader's position exactly by 30 percent, for example, from 100 contracts to 70, the algorithm instantly calculates these 30 percent from the size of your current open position on Binance. After that, the bot sends a market order to close exactly this calculated portion. This guarantees the precise preservation of the specified mirroring ratio regardless of the absolute values of the balance or entry price. Averaging is processed according to a similar principle of proportional volume increase.

I will implement all other technical requirements: I will set up Telegram notifications for trades and errors, create a convenient configuration file for pairs and ratios, deploy the system on your VPS server, and provide detailed instructions. The transfer of the source code and step-by-step payment through escrow is completely acceptable to me.

Budget: 6000 UAH Deadline: 5 days

Good day! I will complete it turnkey. I have experience in implementing such projects. I guarantee the completed work. The exact cost will be calculated after discussing all the details. Shall we discuss?

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: 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: 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: 8000 UAH Deadline: 7 days

Hello! Regarding your main question, partial closure of 30%. I calculate it in shares from the leader's position: the leader closed 30% of their volume, I send a reduceOnly order for 30% of my current volume for this pair. Thus, the ratio remains even after additions and averaging, and reduceOnly ensures that the closure does not accidentally open an opposite position. I keep track of the leader's state between polls and compare each new snapshot with the old one, from which I understand what exactly happened: opening, addition, partial or full closure.

Regarding exchanges: I work with REST and WebSocket API, Binance USDT-M Futures for trading, Hyperliquid via public API, Bitget via read-only key. I will consider the minimum notional and volume step of Binance so that the scalable order does not exceed the limits, and I will process partial fills.

I work in stages, as you want: first Hyperliquid→Binance with a test on small amounts, then Bitget→Binance. Notifications in Telegram for trades and errors, configuration (pairs, ratio, limits), deployment on your VPS with instructions, your code. I look forward to collaborating.

Budget: 10000 UAH Deadline: 8 days

Hello, The task is completely clear. I have extensive experience in developing trading robots and algorithmic trading systems in Python using the ccxt library and an asynchronous approach (asyncio), which is critical for fast polling of multiple exchanges' APIs simultaneously.

Here’s how I will implement the partial closure processing at 30%:
The bot will not be tied to fixed lots of the leader, as your balances and entry prices may differ. The algorithm works through relative mapping of the position delta:
The bot continuously fixes the exact size of the leader's position on Hyperliquid/Bitget.
Upon detecting a 30% reduction in the leader's position from its previous volume (for example, it was 1.0 BTC, now it is 0.7 BTC), the bot calculates exactly 30% of your current actual position on Binance.
The robot instantly sends a market order to close this calculated portion on Binance. This approach works perfectly for both partial closures and averaging (increasing position), maintaining the exact risk proportion regardless of the number of leader orders.

Technical details and architecture:
Stack: Python 3.11+, ccxt (for Binance and Bitget), custom HTTP requests for Hyperliquid API, aiogram (for Telegram notifications).
Reliability: API response validation, network error handling (Rate Limits, Network Timeout) without crashing the script. All settings (pairs, coefficients, limits) are stored in a secure configuration file .env or config.json.
Deployment: I will package the bot in a Docker container and set up auto-start 24/7 via systemd on your VPS. I will provide detailed instructions for managing and updating the code.

Cost and timelines (staged through escrow):
Stage 1 (Hyperliquid → Binance + copy logic, tests): 5 days — 6000 UAH
Stage 2 (Bitget → Binance + TG notifications, deployment on VPS): 3 days — 4000 UAH
Total duration: 8 days.
Final cost: 10,000 UAH. Expand

Budget: 20000 UAH Deadline: 7 days

Hello.

The project suits me. I have developed algorithmic trading systems for Binance and Polymarket, worked with exchange APIs, market data streams, orders, positions, partial executions, state synchronization, and error handling. I also have experience in developing backend services in Python, their deployment, and monitoring on Linux/VPS.

I would build the mirroring not as simple copying of individual trades, but through continuous synchronization of the target position.

For each pair, the bot:

* retrieves the current position of the leader;
* normalizes it to the format and contract limits of Binance;
* applies the specified coefficient;
* compares the target position with the actual position on Binance;
* executes only the difference between them.

For example, if the leader partially closed 30% of the position, the bot will see that the target position size has decreased by 30%, calculate the corresponding difference for Binance, and send a `reduceOnly` order to decrease the position. After the order is executed, the bot will recheck the actual state and, if there is a difference due to rounding, partial execution, or error, will perform a resynchronization.

This approach also correctly handles:

* position increase and averaging;
* partial and full closures;
* direction change Long → Short or Short → Long;
* missed polling cycle;
* manual position change on Binance;
* partial order execution;
* `stepSize`, `minQty`, `minNotional`, and other exchange limits.

I will also add protection against order duplication, logging, Telegram notifications about trades and errors, configuration of pairs, coefficients, and risk limits.

I can implement it in stages:

1. Hyperliquid → Binance with testing on small amounts.
2. Bitget → Binance via read-only API.
3. Deployment on VPS, transfer of source code, and instructions for launching.

Before starting, we will need to agree on the Binance position mode One-way or Hedge Mode, the method of calculating the coefficient, and the bot's behavior in case of manual intervention in the position. Expand

Budget: 15000 UAH Deadline: 7 days

Good afternoon. I have experience in developing similar bots. Let's communicate in private messages, we will discuss everything and get started.

Budget: 7000 UAH Deadline: 10 days

Hello!

I am ready to develop such a bot for you.

I suggest discussing the details in private messages.

Budget: 15000 UAH Deadline: 5 days

Hello Vladislav, I have experience working with exchange APIs. I am ready for collaboration, message me and we will discuss.

Budget: 1000 UAH Deadline: 1 day

Hello! The task is clear: read positions from Hyperliquid and Bitget via API and proportionally mirror them on Binance USDT-M Futures with polling every 5–10 seconds. Partial closure of 30% is processed by reconciling the current and previous position state: the bot sees a decrease in volume by 30% and places the corresponding reduce-only order with the same ratio, separately tracking averaging. Telegram notifications for trades and errors and deployment on your VPS — also no problem. We will discuss the details and step-by-step work through safe in private.

Budget: 15000 UAH Deadline: 10 days

The bot will read positions from Hyperliquid (public API) and Bitget (read-only key), store the current snapshot of each position, and on each polling cycle, compare it with the previous snapshot - any change in size (opening, adding, partial or full closing) is recalculated proportionally with the configured coefficient and applied to the corresponding position on Binance USDT-M Futures with a separate order.

To answer your main question - a partial closing of 30 percent of the position by the leader is not a separate case, but rather the same mechanism of diff comparison of states: the delta is negative, and on Binance, the calculated share of my current position is closed, not a fixed size. Therefore, the mirroring coefficient remains accurate regardless of the absolute figures of the leader's position or entry price. Averaging is processed by the same principle with the opposite sign of the delta.

I will address other requirements in the same way: Telegram notifications about trades and errors, a config file for pairs, coefficients and limits, deployment on your VPS with instructions, the source code will be provided to you, and you will enter the keys yourself. Ready to start with the first stage with phased payment through Safe.

Budget: 2000 UAH Deadline: 2 days

Hello, Vladislav! Partial closure of 30% requires precise tracking of the filled quantity and average entry price on each exchange. Last month, I mirrored between Bybit and Binance for a trader. I am implementing asynchronous polling with state storage of positions in Redis to atomically update the size and price with each partial fill. What size ratio do you plan to use?

Budget: 12500 UAH Deadline: 6 days

Hello!

Regarding your question (partial closure of 30% by the leader):
the bot operates based on the TARGET state, not on events. With each polling, I read the current net position size of the leader → calculate the target for the mirror (leader_size × coefficient) → place a reduce-only order exactly for the difference. So if the leader closed 30% — the mirror will also close by the same 30%. This approach automatically and correctly handles averaging, increases, and missed polls (synchronization corrects itself).

Experience with real-time API: my project is a scanner that reads market APIs from exchanges in real-time, processes positions, and sends notifications to Telegram (Python + FastAPI). The task here is similar, I am adding an example to the bid.

How I will do it:
• Stage 1: Hyperliquid → Binance USDT-M, test with small amounts
• Stage 2: Bitget → Binance
• reduce-only for closures, size coefficient, limits, and pairs in the config
• notifications in Telegram about trades and errors
• deploy on your VPS + instructions, I will provide you with the source code
• you enter the keys yourself (read-only on the sources) Expand

Budget: 12000 UAH Deadline: 7 days

Good day! I have experience working with REST APIs of exchanges and building stable, long-term Python services with polling and Telegram notifications.

I will handle the partial closure of 30% of the leader position as follows: I will store the current size of the mirrored position in the config/DB, and with each polling, I will compare the new leader position with the previous one - if the size has decreased by X%, I will send an order to reduce my position by the same X% (not the absolute delta), taking into account the minimum lot step of Binance. Averaging (increasing with the same direction) is handled similarly - I add a proportional delta. All operations are logged, errors and desynchronizations (for example, manual intervention in the position) are signaled separately in Telegram, not silently.

I am ready to start with the first stage (Hyperliquid → Binance) separately, testing with small amounts, payment through Safe in stages as you propose. The estimated cost of the first stage is 12,000 UAH, duration 7 days. You will enter the exchange keys yourself, the code is completely yours.

Budget: 14000 UAH Deadline: 7 days

30% closing of the leader will be done through State Sync: the bot calculates the percentage change in the leader's position and gives a market order exactly for 30% of your current volume on Binance. No desynchronizations and missed orders due to API lags.

Hello! I am Nina, the manager of the IT agency Valflow. The project developer is Valentin, the founder of our vibe coding school. We will do everything in pure Python quickly and without hacks.

Regarding the stages:
Hyperliquid - Binance (tests on small amounts): 4 days.
Bitget - Binance + Docker + VPS: 3 days.
We work directly with the Binance, Bitget, and Hyperliquid APIs (REST/Websockets). You will enter the keys yourself, the source code is completely yours.

Price: 14,000 UAH
Deadline: 7 days

Message me privately - we will discuss the details and show examples of similar connectors. Expand

Budget: 5000 UAH Deadline: 5 days

Good day!
We have experience working with cryptocurrency exchange APIs (Binance, Bitget, and others), Python, and developing trading bots.
We can implement a bot that:
will receive positions from Hyperliquid (public API) and Bitget Futures (read-only API);
will proportionally open, increase, partially or fully close positions on Binance USDT-M Futures;
will support customizable copy ratios, a list of trading pairs, risk limits, and polling periods;
will send notifications about all trades and errors in Telegram;
will be deployed on your VPS with the transfer of source code and instructions.

Partial closing will be implemented as tracking the change in the leader's position size. For example, if the position decreases by 30%, the bot will calculate the actual percentage change and close 30% of the current position on Binance, maintaining the proportion and direction of the trade. Averaging and increasing positions will be handled similarly.

We are ready to work in stages:
Hyperliquid → Binance with testing on small amounts.
Bitget → Binance after successful verification of the first stage. Expand

Budget: 8000 UAH Deadline: 7 days

Hello!

A mirror for futures is a high financial responsibility. Offers to create such a system for 999 UAH usually do not take into account critical details: rate limits, rounding errors of lots, and WebSocket disconnections during volatility.

I specialize in asynchronous development in Python (aiogram 3, ccxt, asyncio) and offer a reliable, fault-tolerant solution.

Regarding your question about partial closure at 30%:
To avoid desynchronization due to slippage, we copy the proportional share of the leader's position, not their orders.
1. Calculation: We determine the new target size of our position: $S_{\text{target}} = S_{\text{leader\_new}} \times K$ (where K is your copying coefficient).
2. Delta: We calculate the delta (difference) between our current position on Binance and the target $S_{\text{target}}$.
3. Execution: We round the delta to the minimum lot step of the exchange (stepSize) to avoid API errors and send the order to Binance with the "reduceOnly=True" flag. This will protect you from accidentally opening an opposite position.

My approach to architecture:
• Asynchronous polling (asyncio) of Hyperliquid and Bitget every 5 seconds with rate-limit handling (exponential backoff algorithm).
• State storage in SQLite for quick detection of status discrepancies.
• Detailed notifications in Telegram about each action, errors, and balance status.
• Security: API keys are stored only on your VPS in a .env file.

I suggest testing the first stage (Hyperliquid -> Binance) in the test network (Testnet) with micro amounts so you can verify the stability of the logic.

Message me privately, I would be happy to collaborate! Expand

Budget: 10000 UAH Deadline: 10 days

Good day. I have extensive experience working with various APIs, including Binance and Bybit. I also develop algorithmic trading bots. On Binance, the rate reduction occurs by stacking in the opposite direction.

Budget: 27000 UAH Deadline: 7 days

I have practical experience working with the Binance Futures API, Bybit, and other cryptocurrency exchanges, including opening and closing futures positions, partial executions, averaging, Reduce Only orders, leverage control, and state recovery after a restart.

For mirroring, I would use synchronization of the target position size rather than copying individual events.

For example, if the leader had a position of 1 BTC, and after a partial closure, 0.7 BTC remains, the bot determines that the position has decreased by 30%.

```text
target_binance_qty = leader_current_qty × coefficient
order_qty = target_binance_qty - current_binance_qty
```

If the difference is negative, a Reduce Only order is created for the required volume. This approach correctly handles any partial closures, position increases, and averaging.

I would also foresee:

* normalization of symbols and minimum quantity step sizes;
* protection against re-execution of the same state;
* verification of the actual position on Binance after order execution;
* limits on maximum position size;
* Telegram notifications for all actions and errors;
* state preservation for correct recovery after a restart.

I propose to implement the project in stages:

1. Hyperliquid → Binance USDT-M Futures.
2. Testing with small amounts.
3. Bitget Futures → Binance.
4. Deployment on VPS, instructions, and transfer of source code.

You will enter the API keys yourself and store them only on your VPS.

The cost of implementation is 1000 USD. Expand

Budget: 1000 UAH Deadline: 10 days

Hello!
The project is very interesting and clearly formulated. I have extensive experience working with cryptocurrency exchange APIs (Binance, Bitget, Hyperliquid) and developing copy trading bots in Python. I fully understand that the main focus here is on the accuracy of calculations and the stability of error handling to avoid desynchronization of positions.
In response to your question (about partially closing 30% by the leader):
For correct mirroring, I will abandon the logic of "just copying orders" and will build an algorithm based on comparing the current position size (Position Sizing).
During each polling cycle (5–10 seconds), the bot reads the current nominal volume of the position on Hyperliquid/Bitget and compares it with the volume on Binance. If the position on the master exchange has decreased by 30% (regardless of whether it was one limit order, several parts, or through a trailing stop), the bot records this delta, recalculates it using your multiplier, and closes exactly 30% of the current volume of your position on Binance with a market order (or limit within the spread). This approach works perfectly for both partial fixes and averaging (adding).
My experience and stack for implementing the project:
Libraries: I use ccxt (or direct official SDKs from Hyperliquid and Binance) for fast and stable interaction with the API.
Asynchronicity: The bot will be written using asyncio (aiohttp), ensuring instant response and parallel monitoring of both master exchanges without delays.
Logging and Telegram: I will set up detailed logging with file rotation. All successful iterations, partial closures, as well as critical errors (e.g., API Timeout or Insufficient Margin) will be instantly sent to your Telegram bot.
Security: The configuration will be placed in .env or config.json. You will write your API keys there when deploying on VPS.
What limits and leverage do you plan to use? I would be happy to discuss the details and set up reliable software for you.
Best regards,
Victoria Expand

Budget: 3000 UAH Deadline: 8 days

I wrote Python scripts for myself that read other people's positions on Hyperliquid at the wallet address: positions there are returned by a public request without any keys, and polling every 5-10 seconds consumes about two percent of the API limit, so the leader module will work stably and without bans.

Regarding the partial closure of 30%: I do not catch individual deals, but in each survey, I compare the size of the leader's position with what is open on Binance, and I adjust the difference with an order only for reduction. This immediately addresses two pitfalls: the error does not accumulate after a missed survey, and a small fraction goes through even when it is less than the minimum order on Binance, because this restriction does not apply to reductions.

There is also a nuance where such mirrors usually stumble: the names of coins on exchanges do not match. kPEPE on Hyperliquid is 1000PEPE on Binance, but kNEIRO on Binance is simply NEIRO without a multiplier, and PURR or MNT are completely absent there. Therefore, I build the pair correspondence not by names, but by checking the multipliers from both exchanges, plus a separate rule for what to do with a position that is not on Binance.

The start is as you have in stages: Hyperliquid with a test on small amounts, then Bitget (your read-only key for reading positions is sufficient). Notifications in Telegram, setting up pairs, coefficients, and limits in a convenient file, deployment on your VPS - I will do everything and hand over the code.

We will discuss the details in the chat.

Budget: 14000 UAH Deadline: 15 days

Hello. I am ready to develop a Python bot for mirroring positions from Hyperliquid and Bitget to Binance. I have practical experience in creating automated trading systems and a deep understanding of the specifics of working with cryptocurrency exchange APIs. Regarding the handling of partial position closure by the leader at 30%: during polling, the bot records the relative decrease in the leader's position volume and immediately calculates the same 30% of the current size of our open position on Binance, after which it sends a reduction order, allowing for perfect synchronization of balances regardless of the set ratio. All functionality with averaging, limits, and pair settings will be moved to a convenient config, and Telegram notifications will instantly inform about successful trades and possible errors. I fully support a phased work format: first, we will set up and test the connection with Hyperliquid with small amounts, and in the second phase, we will connect Bitget. After the development is completed, I will deploy the bot on your VPS, provide detailed instructions, and hand over the source code.

Budget: 5000 UAH Deadline: 5 days

Hello, I have extensive experience working with the Binance Futures API and the APIs of other exchanges. I implemented partial position closures in a bot that was engaged in placing laddered positions (if the price goes up, we sell; if it goes down, we buy). I developed a bot based on ZigZag signals from my own indicator. There are also many others. If you are interested in the quality execution of your project, please write. The price is indicated for the first stage Hyperliqued -> Binance. The second part will cost the same.

Budget: 2000 UAH Deadline: 3 days

Hello, I have ready-made cases implemented for Binance Futures, I can show examples and quickly adapt them to your needs.

Budget: 8000 UAH Deadline: 5 days

Hello!

I have extensive experience in developing crypto bots (algorithmic trading, copy trading, arbitrage) in Python using ccxt and direct exchange APIs (WebSockets/REST). I am well acquainted with the Binance Futures API, Bitget, and the specifics of working with the decentralized Hyperliquid.

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: 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: 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: 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: 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: 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 :)