
Open
Posted
•
Ends in 1 day
Paid on delivery
WANT TO USE BAR STATISTICS DATA FOR EXECUTING ORDERS TO MY TRADING ACCOUNT
Project ID: 40800923
61 proposals
Open for bidding
Remote project
Active 1 day ago
Set your budget and timeframe
Get paid for your work
Outline your proposal
It's free to sign up and bid on jobs
61 freelancers are bidding on average ₹23,489 INR for this job

Hello bro, Contact with me on chat box, I will assist you to using Bar Statistics Data for Executing orders to your Trading Account as you expecting. Thanks~Eng. Bablu.
₹12,555 INR in 2 days
5.8
5.8

Hello, Problem: The algo bot needs reliable market data from GoCharting and the NSE option chain to generate and execute trades accurately. Solution: With 20 years of software development experience, I can build or refine the bot’s data ingestion, option-chain parsing, strategy logic, and order execution. I’ll add error handling, risk controls, logging, and backtesting or paper-trading validation where applicable. Result: A dependable trading workflow with clearer signals, controlled execution, and traceable results. 1. Which strategy and entry/exit rules should the bot follow? 2. Which broker API will handle order execution? 3. Do you have existing code or should this be developed from scratch? Thanks
₹26,000 INR in 7 days
5.6
5.6

GoCharting doesn't offer a public API for Bar Statistics, so pulling that data usually means tapping a WebSocket feed that can break on any UI update. NSE also blocks repeated option chain requests, so a bot can fire orders on stale data. Quick questions - which broker API is your trading account on (Zerodha Kite, Upstox, Dhan)? And do you need sub-second execution, or is acting on a 1-minute bar close fine? Here is the architectural approach: - PYTHON DATA LAYER: Capture GoCharting Bar Statistics and NSE option chain data with session handling, retries and staleness checks. - C++ EXECUTION CORE: Move order logic to C++ only if latency demands it, otherwise keep it lean in Python. - RISK CONTROLS: Add max-loss limits, position caps and a kill switch before any order hits your trading account. I've built Python trading systems that run on live market fe
₹22,500 INR in 7 days
5.5
5.5

Hi, I can build an automated system that reads your bar statistics and places orders on your trading account based on rules you define. Typical setup: Data: read bar data (OHLC, volume, or custom statistics) from your platform or data feed Logic: turn your entry/exit rules into code, with position sizing, stop-loss and take-profit Execution: send orders through your broker’s API or platform (MT5, NinjaTrader, TradingView alerts → broker, Interactive Brokers, etc.) Safety: demo-account testing first, max-loss and max-position limits, a kill switch and trade logs To quote accurately, I need: Which platform and broker do you use? What does “bar statistics” mean here (e.g. OHLC, volume, delta, an indicator or exported file)? Can you share the exact rules for when to buy or sell?
₹25,000 INR in 7 days
5.2
5.2

Hello, You need an algo trading bot that uses GoCharting bar statistics data and NSE option chain feeds to execute automated orders into your broker account. I will build a Python automation engine that ingests GoCharting webhooks/data alongside live NSE option chain metrics to trigger exact trade logic. A Flask backend will handle data parsing, rule evaluations, and order dispatch directly to your broker API with full error logging. Deliverables: - GoCharting data parsing script and webhook endpoint - NSE option chain monitoring and strategy logic engine - Broker API execution module with risk management and logging Timeline: 10 days Cost: INR 14,000 for Milestone 1 covering data ingestion and strategy setup, with full integration and testing totaling INR 14,000 to INR 25,000 within your budget. Backtests and paper-trading simulations show past performance, not future profits. Which broker API will you be using for order execution, and how are you exporting the bar statistics data from GoCharting? I can share examples of python options bots I built in chat. Thanks, Prashant
₹25,000 INR in 10 days
5.6
5.6

Hello, I can develop an automated trading system that uses Bar Statistics data to generate trading signals and execute orders directly through your broker's API. **Proposed Solution:** - Integrate live Bar Statistics and OHLCV market data. - Analyse candle patterns, price movements, volume, and statistical indicators. - Implement configurable BUY/SELL entry and exit conditions. - Automate order placement through broker APIs such as Zerodha Kite Connect. - Include stop-loss, target, position sizing, and risk management. - Maintain trade logs with timestamps, execution prices, quantities, and signals. - Provide a dashboard to monitor orders, positions, and P&L. **Technology:** Python, Pandas, NumPy, Kite Connect API, WebSockets, and SQLite. I can also integrate your existing Python strategy instead of rebuilding it from scratch. **Deliverables:** Fully documented source code, automated execution, error handling, testing, and deployment assistance. I recommend starting with paper trading to validate the strategy before enabling live execution. Please share your broker API details and Bar Statistics calculation logic so I can assess the requirements and propose an implementation plan. Looking forward to collaborating!
₹25,000 INR in 1 day
4.8
4.8

Hi, there. I am ready everything. I will give you perfect result. I want to discuss with you in more detail now
₹20,000 INR in 2 days
3.9
3.9

1. Bar data processing Retrieve historical and real-time OHLCV data. Process configurable candle intervals. Calculate relevant bar statistics, including price ranges, body size, wicks, volume, and volatility. Identify patterns and conditions based on your trading rules. 2. Trading strategy implementation Translate your entry and exit conditions into modular Python logic. Generate buy and sell signals from bar statistics. Support configurable indicators, thresholds, and timeframes. Include position sizing and risk-management rules. 3. Trading account integration Connect to your broker or trading platform through its supported API. Implement order placement and execution-status tracking. Handle rejected orders, connection failures, and duplicate signals. Start with paper trading before enabling live execution.
₹25,000 INR in 7 days
4.0
4.0

Hi, Latent mismatches between GOCHARTING bar statistics and live NSE OPTION CHAIN ticks are the highest risk: misaligned timeframes or delayed bar aggregation can trigger incorrect order execution against your trading account. I would first lock down time-sync, symbol mapping, and aggregation windows so the bar statistics used for signals always match the live option chain snapshots. I have built trading systems that ingest web-socket and REST data from market-data providers, normalize bar-level statistics, run signal engines, and execute orders via broker APIs with pre-trade checks and circuit breakers. I have integrated option-chain parsers and created order managers that enforce position limits, slippage tolerances, and layered retries for failed fills. I can adapt those components to use GOCHARTING bar statistics combined with NSE OPTION CHAIN feeds and drive your execution account with safe automation. I will begin by connecting to GOCHARTING and the NSE OPTION CHAIN source you use, validate timestamps and bar aggregation, and run a short replay/backtest on historical bar statistics to verify signal fidelity. The first concrete step is a live dry-run mode that simulates orders against your account without sending fills. - Do you already have API access credentials for your broker and for GOCHARTING and the NSE OPTION CHAIN feed? - Which specific execution rules must I enforce (max position per leg, max daily loss, slippage limit)? Thank you, @melopgabriel
₹12,580 INR in 126 days
4.1
4.1

Hi, I understand you want to use the bar statistics from GoCharting together with NSE option chain data to generate signals and execute orders in your trading account. The important part here is making the data flow reliable first, then keeping the execution logic separate so the strategy can be tested and adjusted without risking unintended orders. I can build the Python side to collect/process the required data, apply your entry conditions, and connect the resulting signals to the trading account once the exact broker/API and execution rules are confirmed. Before placing live orders, I would also make sure the system handles missing data, duplicate signals, API failures and position state correctly. Please share the existing project/data from 40800923 and I can work from the current setup rather than rebuilding unnecessarily. Kind regards, Fernando
₹13,160 INR in 3 days
3.7
3.7

Hi, how are you doing? I have considerable experience with building trading integrations and executing orders using data-driven decisions. I have deployed projects that connect bar statistics to order execution, handle risk checks, and place trades reliably. I can demo previous work if needed. let me know further information, if interested. Let me know further if interested.
₹37,500 INR in 5 days
3.4
3.4

HELLO "bar statistics data for executing orders to my trading account" - the bot needs reliable GoCharting and NSE option-chain data connected to controlled order execution. I'll build the Python trading workflow to ingest the required market data, calculate signals from your bar statistics, and route orders through your broker's supported API. I'll include position checks, duplicate-order protection, reconnect handling, and detailed execution logs, with paper trading and validation before live deployment. Which broker and API will the bot use, and what exact bar-statistics conditions should trigger an order? I appreciate your consideration. THANKS
₹30,000 INR in 21 days
3.4
3.4

My experience in algorithmic trading, NSE/BSE markets, option strategy automation, and financial analysis directly matches your need to use GoCharting bar statistics and NSE option-chain data for trade execution. I can use Python to build the automation connecting market data with your trading account while keeping the logic structured, accurate, and scalable. My background also includes financial modeling and backtesting, which supports reliable evaluation of bar-statistics signals before they are used for live order execution. Alongside 12+ years in data and automation, my MBA and Postgraduate Diploma in Computer Applications help me combine technical implementation with a clear understanding of trading workflows and business requirements. I am ready to apply my Python, market-data, and trading automation expertise to this project and would be pleased to build a dependable solution for your trading strategy.
₹25,000 INR in 7 days
3.5
3.5

Hello, I can build this in Python on your broker's API (Zerodha, Dhan, Upstox, Fyers or Angel One). GoCharting has no data API, so the bot rebuilds the same bar statistics you read there (volume, buy and sell volume, delta, OI change per bar) from the live tick feed. It also reads the NSE option chain (OI, change in OI, PCR) through the broker's chain feed, then places orders by your rules with stop loss, target, max trades and a daily loss cap. Before any live order, I check every bar's numbers against your GoCharting screen and run your rules in paper mode. It runs on a VPS with a static IP, as SEBI's algo rules require, with a clear log and a stop switch.
₹22,000 INR in 4 days
3.5
3.5

Hi, I can help develop a trading system that uses bar statistics data, such as OHLC, volume, volatility, and price movements, to generate trading signals and execute orders through your trading account. I can work on integrating your broker's API, defining entry and exit conditions, implementing risk-management rules such as stop-loss and position sizing, and adding order monitoring and execution logs. I’d recommend starting with historical backtesting and paper trading before enabling live order execution. Please share your broker or trading platform, the bar statistics data source, and the strategy or rules you want to implement.
₹28,000 INR in 7 days
2.8
2.8

Hi, Melih Here >> "GOCHARTING BAR STATISTICS AND NSE OPTION CHAIN EXECUTION" - you need reliable trading signals converted into orders in your trading account. I would use Python to collect and process GoCharting bar statistics alongside NSE option chain data, then apply clear entry and exit rules before sending orders through your broker API. Order failures, delayed data and duplicate signals must be handled to avoid unwanted trades. Which broker and trading API are you currently using? Looking forward to work with you.
₹13,160 INR in 3 days
3.0
3.0

Hi, there. I recently engineered a high-frequency trading bridge that parsed real-time order book depth data to execute limit orders based on specific liquidity thresholds and sub-millisecond price movements. I implemented a custom WebSocket-based engine to monitor volume spikes across multiple price levels simultaneously, which solved a critical execution latency issue by utilizing a multi-threaded Rust architecture to decouple data ingestion from the order execution logic. I offer to implement a reactive architecture using ZeroMQ or Go to process incoming bar statistics without blocking the main execution thread. I am planning to utilize a state machine to track order status and ensure that execution logic triggers only when statistical patterns match your predefined risk parameters. My approach involves using a low-latency Redis cache to store historical bar data for rapid calculation of technical indicators during high-volatility periods. If I use my previous experience, your project will likely be completed successfully. Hope to discuss this in detail. Through detailed discussion, I think I can find the better solution to finish your project successfully. Thank you
₹25,000 INR in 7 days
2.6
2.6

Hello, You're looking to pull bar statistics (like OHLC data) from your trading platform and use it to trigger automated orders. The tricky part here is making sure the execution logic handles edge cases, like partial fills or sudden price gaps, without blowing up the account. I'd start by connecting to your broker's API (MT4/5, IBKR, etc.) to fetch the bar data, then build the order logic in Python with checks for volatility and liquidity. For backtesting, I'd use a library like Backtrader to simulate fills realistically before going live. I delivered something similar last month, an automated trading script that managed risk based on real-time price action. Do you already have a preferred broker API, or should we plan for a generic solution?
₹12,840 INR in 15 days
2.5
2.5

I can help build an automated trading execution system that uses bar statistics data to generate trading signals and execute orders through your connected broker account. I'll first understand your bar statistics, trading conditions, and execution requirements. Then I'll develop the integration to process incoming market data, evaluate your defined entry and exit conditions, and send orders through the broker's supported API. I'll also implement configurable position sizing, stop-loss and take-profit rules, duplicate-order prevention, execution logs, and error handling. I'll begin with paper trading or a sandbox environment to verify signal accuracy, order placement, and execution behaviour before connecting to your live trading account. The system will follow your specified trading rules; profitability cannot be guaranteed.
₹25,000 INR in 1 day
2.1
2.1

Hi, We can build a Python-based algorithmic trading bot that uses GoCharting bar statistics and NSE option-chain data to generate trading signals and execute orders through your brokerage account. The system will be designed to capture market data, process the required bar statistics and option-chain parameters, apply your trading conditions, and trigger orders automatically. We'll also include position monitoring, configurable risk controls, execution logs and API error handling. The implementation will focus on reliable data processing and order execution, with a modular structure that allows trading rules to be refined without rewriting the entire system. We can complete the full implementation within 4 days for ₹18,000. Milestone Breakdown ₹3,000 | Data Integration: Connect GoCharting data and NSE option-chain inputs. ₹6,000 | Signal Engine: Process bar statistics and implement trading conditions. ₹6,000 | Broker Integration: Implement order execution, position tracking and risk controls. ₹3,000 | Testing & Handover: Validate workflows, resolve issues and provide setup documentation.
₹18,000 INR in 4 days
1.8
1.8

VASCO DA GAMA, India
Payment method verified
Member since Dec 22, 2021
₹12500-37500 INR
$15-25 USD / hour
₹750-1250 INR / hour
$250-750 USD
$30-250 USD
$30-250 USD
$750-1500 AUD
₹1500-12500 INR
$250-750 USD
$250-750 USD
$30-250 USD
$250-750 USD
₹12500-37500 INR
$250-750 USD
$750-1500 USD
$250-750 USD
$750-1500 USD
$250-750 USD
$250-750 USD
₹12500-37500 INR
₹600-1500 INR