I am completely satisfied with the collaboration. Developed a bot for Bybit according to my specifications. The work was completed within the agreed timeframe, the code is clean and well-documented. The contractor demonstrated high competence: warned in advance about technical nuances (API limits, WebSocket), anticipated error handling and recovery from failures. The bot has been successfully launched on a VPS and is working stably. I recommend for collaboration.
32
0
Budget: 200 USD Deadline: 5 days
Hello.
The task is clear and technically well described — that's a plus. I have good experience with Python bots, working with APIs, WebSocket / REST, event monitoring logic, state storage in databases, and building scenarios where it is important not just to "get data," but to correctly track the chain of conditions and not break the logic in edge cases.
According to your specifications, I can implement the bot carefully and structurally:
— filtering all USDT futures on Bybit by turnover24h
— finding and saving all lower 3-candle fractals
— storing fractal statuses in SQLite without duplicates
— real-time monitoring of fractal removals via WebSocket
— launching waiting logic for bullish FVG after a sweep
— controlling cancellations based on a lower fractal, sweep_low, and fvg_wait_days
— finding FVG based on the rule Low(3) > High(1)
— one-time Telegram notifications
— logging, error handling, and database cleanup based on statuses at startup
I like that you have already thought out the statuses well:
active → waiting_for_fvg → sent / lost / expired
This is exactly the right approach for such a bot because here state-driven logic is important, not just a simple "signal scanner."
How I would structure it:
— a separate Bybit API module
— a separate fractal scanning module
— a separate real-time monitoring module
— a separate FVG logic module
— a separate SQLite working layer
— a separate Telegram notifications module
— configuration through config.json, to easily switch between D1+H4 and 1W+D1 modes
That is, without a mess in one file and with the possibility of further expanding the bot.
What is included in the work:
— complete bot code in Python
— setup of both operating modes
— SQLite structure and cleanup logic
— logging and protection against the entire process crashing due to one coin
— startup instructions
— assistance with initial launch and verification
Regarding timelines:
approximately 4–7 days
Regarding cost:
$150–300, depending on whether a simple working version according to the specifications is needed or an immediately well-structured project with proper structure, logs, and ease of further support.
If you want, I can also briefly outline how the file architecture and the bot's workflow from launch to signal sending will look — to fix the logic without surprises before starting.
Budget: 200 USD Deadline: 1 day
✋ Hello! We are the IT company dZENcode.
We can create a bot for this strategy and Telegram notifications for you.
Do you need one mode or support for both?
Where is it more convenient to store and clean the database?
You can find detailed information about our services and rates on our website: 
Freelancehunt
Take a look – we will discuss the details of the work further, write when you are ready.
The final cost is determined only after clarifying the scope and requirements.
___________________
Best regards,
Manager of dZENcode
Our strengths:
💎 10+ years providing IT services: Outsourcing, Outstaffing
🔥 90+ in-house specialists
🚀 Projects "from scratch" and for support
⚙️ SLA and post-production support
✅ Contract with the company, guaranteed results!
🔥 250+ public reviews since 2015.
4
0
Budget: 850 USD Deadline: 7 days
Hello.
I have reviewed the technical specifications. Here, we need not just a scanner for Bybit, but an event-driven strategy with a clear state machine: searching for fractals on a higher timeframe, instant tracking of their removal through tick data, then searching for bullish FVG on a lower timeframe and controlling all cancellation conditions before sending the signal.
From a technical point of view, it is important to separately distinguish:
- REST for historical candlestick data and initial scanning
- WebSocket for the moment of level removal
- storage for fractal states and anti-duplicates
- scheduler for two operating modes
- Telegram as the signal channel
This approach allows implementing both modes with one architecture, without duplicating logic. I can assemble this as a stable MVP with correct handling of `active / waiting_for_fvg / sent / lost / expired`, logs, and protection against duplicate notifications.
Before starting work, I need to clarify:
- whether both modes are needed at once
- whether there is already a choice regarding the `pybit` library / other clients
- whether a separate dry-run / testing mode is needed
- whether there is a preferred format for logs and Telegram messages
In personal messages, I will answer all questions in a language convenient for you (Ukrainian, Russian, English).
34
0
Budget: 25 USD Deadline: 7 days
Good day, I specialize in the development of bots and automation of actions in the browser. In the history of completed projects, there are successful cases involving complex trading terminals and arbitrage systems on Bybit and Binance.
14
0
Budget: 500 USD Deadline: 3 days
Hello, Albert! I am Nina, the manager of the developer engineer Valentin.
Your technical specification is a model of clarity. We understand that determinism (no randomness in defining levels) and the speed of response to liquidity removal are critically important in this strategy.
Why choose Valentin:
Valentin works using AI-augmented development methodology. This allows us to design and test complex algorithms (like your order cancellation system and sweep_low monitoring) three times faster while maintaining industrial code quality.
How we will implement the bot:
Reliable Database: We use SQLite optimized for concurrent writing (WAL) so that monitoring 100+ pairs does not block the database.
WebSocket Engine: We implement instant breach level fixation "tick by tick" through the Bybit stream, without waiting for the candle to close.
Strict cancellation logic: The bot will clearly track conditions No. 1, No. 2, and No. 3, preventing false notifications and saving your time.
Clean code in Python: We use asynchronous programming (asyncio) so that a failure with one coin does not affect the entire process.
Timeline: 3–5 working days.
Budget: $450 – $550 (depends on the need for additional log settings).
Albert, please clarify: should the notification include a chart with the marked FVG zone, or are textual data and levels sufficient?
Best regards, Nina.
2
0
Budget: 700 USD Deadline: 10 days
Hello, Albert!
The technical specification is detailed and has a clear state machine — it's a pleasure to work with. Regarding the implementation:
— Fractal search (fractal_tf): an asynchronous scanner for USDT futures with a filter of turnover24h ≥ 150,000, requesting 1,000 candles, detecting three-candle lower fractals, deduplication by (symbol, level, date) before writing to SQLite with the status active.
— Monitoring: WebSocket for tickers for the removal event (by Low). State active → waiting_for_fvg → lost/confirmed. Separate REST polling on fvg_tf candles to search for bullish FVG.
— Cancellation condition No. 1 — live through the same WebSocket, detect a new lower fractal below the current one → reset to lost.
— Scheduler: 00:10 UTC through apscheduler or asyncio-loop with precise next_run.
— Telegram notifications: one bot, message format with symbol, level, removal price, time, TF.
— Config through config.json: fractal_tf, fvg_tf, turnover_threshold, telegram_token, mode.
Stack: Python 3.11 + asyncio + pybit + aiosqlite + apscheduler + aiogram.
One clarifying question: is cancellation condition No. 1 checked by the Low tick in real-time, or only at the closing of the fractal_tf candle? The technical specification shows that sweep_low is recorded BEFORE the candle closes — which means the cancellation condition also works live. Please clarify just in case, to avoid discrepancies in edge cases.
Cost: 700 USD turnkey.
Deadline: 10 days — the first working run on test symbols in 5-6 days, final with documentation by the 10th.
Experience: I have worked directly with the Bybit API — wrote scripts for collecting market data and automation. I have also worked with the OKX API. Python async + state machines + SQLite and Telegram integrations are my daily stack.
If this works for you — write to me, we will discuss the details and clarifications regarding the technical specification.
1
1
Budget: 200 USD Deadline: 1 day
Good day. I am ready to complete this project and have extensive experience in developing various applications.
2
0
Budget: 400 USD Deadline: 7 days
Hello. The technical specification is excellent, everything is extremely clear. I am ready to take on the implementation. I am ready to get to work.
I specialize in Python backend and crypto bots. To ensure the bot maintains a stable data flow for 100+ coins, I will incorporate the following solutions into the architecture:
I will make everything asynchronous: I will use asyncio and aiosqlite. This means that requests via WebSocket and REST API will not interfere with each other.
I will optimize the database setup: I will enable WAL mode in SQLite. The fractals that are constantly used will be stored in memory to prevent the database from blocking when there are many ticks.
I will ensure the system is fault-tolerant: the WebSocket will automatically reconnect thanks to the pybit library. I will isolate exceptions - a failure with one coin will not stop the entire monitoring.
I will deploy the bot reliably: I will configure it to run on Amazon EC2 (or your server) via systemd with log rotation. The bot will operate autonomously 24/7.
I will write clean code, and all calculations for FVG and fractals will be mathematically accurate.
10
0
Budget: 300 USD Deadline: 7 days
Good day!
I have experience in developing software for monitoring any data from the ByBit exchange.
Your approach is clear to me; I have a couple of ready-made search functions that will suit your project.
If I understand correctly, we are talking about covering the imbalance.
I have many ideas for implementing multithreading for the software; write to me, and we will discuss the details and get started!
Sincerely, Andrey!
74
1
Budget: 400 USD Deadline: 10 days
Good day. I have real experience in developing trading algorithmic bots. I am ready to complete your project. Write to me, we will discuss. I will be glad to cooperate.
11
0
Budget: 21732 USD Deadline: 5 days
Hello! We are the SDEV team — developers and engineers with experience in implementing complex bots and systems in Python. Your project requires integration with the Bybit API, processing candlestick data, monitoring fractals and FVG, as well as sending notifications to Telegram.
Our implementation includes:
- Analysis of USDT futures with a volume filter (≥150,000 USDT)
- Searching for three-candle fractals on D1/1W, tracking their removal
- Dynamic search for bullish FVG on H4/D1
- Working with WebSocket and REST API Bybit
- Logging actions and handling exceptions
- Storing data in SQLite with cleaning of old records
We will implement this using Python, pybit, sqlite3, websockets, and requests. We have experience in creating Telegram bots with flexible logic and integration with trading platforms.
53
4
Budget: 500 USD Deadline: 5 days
Good day. I have extensive experience working with all popular cryptocurrency exchanges, including Bybit. I have completed a similar project for BingX and Biconomy. I am ready to implement your project after discussing the details in private messages.
Budget: 1100 USD Deadline: 7 days
Good morning,
Regarding your order for creating a bot - please respond :)
The timeline and project estimate provided here are only preliminary - after receiving detailed information in your response - I will prepare my exact proposal for you with technical assumptions - and an estimate in the form of a PDF file.
----------------
Best regards,
Przemysław Barycki
692 - 831 - 062
Budget: 704 USD Deadline: 7 days
ready to help you out
will share prevoius work in chat to make sure we are match
--------------------------------------------------------
20
0
Budget: 550 USD Deadline: 17 days
Good day!
I have studied the technical specifications in detail - it is very well written, all states and transitions are clearly described, without ambiguities. It is pleasant to work with such specifications.
I have experience in developing trading bots in Python: working with exchange APIs (REST + WebSocket), real-time monitoring, candlestick patterns, Telegram notifications, SQLite.
I am ready to take on the project. Regarding the timeline - approximately 5-7 working days.
11
0
Budget: 600 USD Deadline: 7 days
Good day!
I am engaged in the development of signal bots.
I develop in Python.
I have completed more than one similar project.
I will do it quickly, efficiently, and most importantly, turn-key.
Write to me - we will discuss.
1
0
Budget: 25 USD Deadline: 1 day
Hello! We are the NovaCore Solutions team. We have significant experience in developing robust real-time systems and trading bots, so we will implement your algorithm with fractals and FVG with special attention to the accuracy of WebSocket data and the stability of the SQLite database. We will ensure correct processing of fractal states (active/waiting/lost), set up clear cancellation logic for sweep_low and filtering by volume, guaranteeing the absence of duplicates and reliable logging of each step. We are ready to turn your technical specifications into a clean working implementation and discuss the final details in private messages.
5
1
Budget: 1374 USD Deadline: 14 days
Hello, Albert!
I have read the technical specification carefully, the stack (Python + pybit + WebSocket + SQLite + Telegram) is my profile. A few clarifying questions:
1. Condition for cancellation #1 (new lower fractal) — is it checked in real-time via WebSocket or at the closing of the candles fractal_tf?
2. sweep_low is fixed after the closing of the candle fractal_tf — until the closing, condition for cancellation #2 is not active, correct?
3. If the fractal has several bullish FVG during the waiting period — notification only on the first + status sent?
I propose 3 milestones:
M1 — Base (3-4 days, $400)
Setup, config, logging, Bybit API, turnover filter, SQLite schema, search for three-candle fractals with deduplication. Working prototype — it can be checked that the fractals are found correctly on real data.
M2 — Real-time strategy (5-7 days, $550)
WebSocket monitoring of fractal removals, state machine (active → waiting_for_fvg → sent/lost/expired), bullish FVG detector, all three cancellation conditions, error handling per coin.
M3 — Finalization (2-3 days, $300)
Scheduler 00:10 UTC for both modes, support for 1W+D1 via config, Telegram notifications, database cleanup (30 days), README with deployment instructions.
A detailed plan with phase breakdown, technical solutions for WebSocket monitoring, logic of the state machine, handling edge cases, pricing options, and my clarifying questions regarding the technical specification are outlined separately to avoid overloading the response:
📋 Full proposal with details: https://www.notion.so/Bybit-bullish-FVG-341ea80ec59480438955cc55e22b93a7?source=copy_link
Overall: $1250 + $124 I allocate for service commission - we can do 50/50, fixed price, deadline 10-14 working days.
I use Claude Code as an accelerator for boilerplate parts (API integration, SQLite, scheduler). I personally control the strategy logic and testing of edge cases — this is not the part where one can rely on AI.
All acceptance criteria from the technical specification will be checked before the delivery of each milestone.
Portfolio and examples of relevant projects: [Notion link]
I am ready to start M1 immediately after the milestone is funded. Please provide a read-only API key for Bybit after the contract is created.
Thank you, I look forward to your response!
8
0
Budget: 500 USD Deadline: 5 days
Hello, Albert! I already have a working bot for parsing Bybit/Binance with similar logic, I can modify it for your request, write to me to discuss the details, I will be happy to collaborate on your project!
2
0
Budget: 498 USD Deadline: 6 days
I am ready to take on the implementation of a bot for Bybit according to your specifications: lower three-candle fractals on a higher timeframe, tick removal, searching for bullish FVG on a lower timeframe, filtering by turnover24h, modes D1+H4 and 1W+D1, SQLite, Telegram, and scheduling in UTC. The public API for market data is available; I will do it in Python with logging and in such a way that an error on one pair does not stop the entire monitoring. I can start after agreeing on config.json and acceptance criteria.
9
0
Budget: 800 USD Deadline: 7 days
Write in private messages, I will write a trading bot for you and set it up on 24/7 hosting.
Budget: 1000 USD Deadline: 10 days
Good day. I have been trying to gather similar trading algorithms for MEXC, I understand the specifics.
The main difficulty here is not to get banned due to rate limits while scanning hundreds of coins and to properly handle WebSocket disconnections so that the fractal statuses do not drop during a breakout.
I suggest breaking it down into stages; for now, I propose the following, then I will consult with AI, maybe it will come up with something better:
REST API and Database: coin filter, fractal search on history, recording without duplicates — 2 days / $200.
WebSocket: instant withdrawal by tick, fixation of lows, status changes — 3 days / $350.
FVG logic and alerts: search after withdrawal, cancellation conditions, Telegram — 2 days / $250.
Tests and optimization: setting timeframes, handling socket disconnections, database cleaning — 3 days / $200.
Total: 10 days, $1000.
If this format of work suits you — write, we will start with the first module.
35
1
Budget: 800 USD Deadline: 3 days
Hello. I will do everything according to the specifications, but in PHP. I have experience in developing similar bots, as well as in searching for fractals. Feel free to contact me.
13
0
Budget: 1500 USD Deadline: 5 days
Hello.
I have reviewed the technical specifications - the task is completely clear, including the logic of fractals, their life cycle, and the scenario with FVG after removal. This is not just a "scanner," but a full-fledged state machine with events and cancellation conditions - exactly the type of systems I work with.
What I will do for implementation:
1. Architecture
I will divide the system into modules:
MarketData (Bybit REST + WebSocket)
FractalScanner (searching and recording fractals)
FractalEngine (life cycle: active → waiting → sent/lost/expired)
FVGDetector (logic for finding FVG on a lower time frame)
Storage (SQLite)
Notifier (Telegram)
All states of the fractals will be processed as events, not "in a loop" - this is critical for stability.
2. Data Handling
WebSocket for ticks (instant removal of fractals)
REST for candles (fractal_tf and fvg_tf)
Separate scheduler for D1+H4 / 1W+D1 modes
Caching candles to avoid unnecessary API calls.
3. Strategy Logic
Clear implementation of three-candle fractals without "pseudo-conditions"
Real-time tracking of removals, without waiting for the candle to close
Correct fixation of sweep_low after the closing of the fractal_tf candle
Full support for all cancellation conditions (lost / expired)
FVG strictly according to the rule: Low(3) > High(1), without exceptions.
4. Reliability
An error with one coin does not break the system
Logging of all stages (removal, cancellation, found FVG)
Protection against duplicates in the database (symbol + level + date)
Database cleanup according to rules (30 days).
5. Telegram
Notification strictly once per fractal
Full format, as in the technical specifications (levels, dates, zone, volume).
💡 Important point:
There are several non-trivial aspects in your technical specifications that I already see:
synchronization of WebSocket (tick) and candles (REST)
correct determination of the moment of "removal" within the current candle
race condition control (for example, two fractals removed in a row)
I will take this into account in the architecture so that the bot does not give false signals.
Proposals concealed
The list does not show proposals concealed by the client or freelancer with a Plus profile, as well as proposals violating rules