
In Progress
Posted
Paid on delivery
I need a Python-driven trading system that scalps equities and derivatives on the National Stock Exchange (NSE). The core logic will blend market-making techniques with price-action signals, working exclusively from live market data pulled through a low-latency feed or broker API. The algorithm must: • Subscribe to real-time order-book depth, trades and tick data. • Calculate fair value and micro-price shifts to quote two-sided markets (market making) while simultaneously scanning candlestick patterns, breakouts and momentum cues (price action). • Place, amend and cancel orders in milliseconds, respecting exchange throttles and broker limits. • Apply position sizing, max-loss stops, and session P&L caps to keep risk tight. • Log every decision and fill to a local database or flat files for later analysis. Code in modern, well-commented Python 3, using popular libraries such as asyncio, websockets, pandas and NumPy. Wrap broker connectivity (e.g., Kite Connect, IIFL, Fyers or similar) behind clean interfaces so I can swap providers if needed. Unit tests and a short README should be included so I can spin the bot up quickly on my VPS or local machine.
Project ID: 40750432
53 proposals
Remote project
Active 5 days ago
Set your budget and timeframe
Get paid for your work
Outline your proposal
It's free to sign up and bid on jobs

Hi, Albert here, from Philippines. What matters most in building your Python NSE scalping algorithm with pandas and WebSockets is numbers people trust and use to make decisions. I'm a senior software developer with 10+ years of experience working with Python, C++ Programming and Data Analysis. The real challenge is the data behind the charts: messy sources, mismatched definitions and refresh failures in pandas. A common issue: building visuals before agreeing how each number is calculated, so reports disagree. My plan: first, agree each metric, its definition and its data source. Then, clean and model the data, and build the report pages in pandas. Finally, check totals against the source and set up scheduled refresh. I've done reporting work in C++ Programming. A few questions to better understand the scope: 1. Is any source a spreadsheet updated by hand? Manual sheets break refreshes, so I add checks for renamed columns. 2. Start with one page that answers the top question? I'd recommend it, one trusted page beats ten unused ones. 3. Who reads the dashboards, managers or analysts? Managers need a few clear numbers, analysts need filters. I can start right away. Happy to go over the details here in chat and suggest the best approach. Looking forward to hearing from you, Albert
₹12,950 INR in 2 days
3.0
3.0
53 freelancers are bidding on average ₹24,785 INR for this job

Building an abstract broker interface in Python that processes live order-book depth for micro-price quoting while scanning price-action signals requires clean asynchronous handling. I build Python automation and trading bots, including my Telegram trading bot project and API integrations with platforms like Shoonya. For your NSE scalper, I will structure: - An abstract base broker class using asyncio to handle WebSocket tick streams and order routing, making it simple to plug in Kite Connect or Fyers. - A quoting and signal engine in NumPy and Pandas to compute micro-price shifts and candlestick triggers while respecting broker rate throttles. - Hard risk controls covering position limits, session loss caps, local execution logging, unit tests, and a clear VPS setup guide. I work on pre-agreed milestones. Which broker API do you want to target first for initial testing? Ahmed
₹21,500 INR in 5 days
5.6
5.6

Hi there, I am python hub , i understand what you want exactly , Can you please come to the chat box so we can easily discuss in details, Will provide you quality work in very short time with the source code and documentary Thank you
₹35,000 INR in 2 days
5.8
5.8

Your NSE scalping bot will fail if you don't handle exchange throttle limits correctly — most brokers cap order placement at 10-20 requests per second, and breaching that will lock your account mid-session. You also need sub-100ms latency between tick reception and order placement, or you'll be front-run on every breakout signal. Quick questions - are you running this on a co-located VPS near NSE servers to minimize network lag? And what's your target position hold time — under 30 seconds or closer to 2-3 minutes? Here is the architectural approach: - ASYNCIO + WEBSOCKETS: Build event-driven order-book ingestion using asyncio to handle concurrent tick streams without blocking execution threads, ensuring sub-50ms tick-to-trade latency. - NUMPY + PANDAS: Implement vectorized micro-price calculations and rolling candlestick pattern detection using NumPy arrays to process 1000+ ticks per second without Python's GIL bottleneck. - BROKER API ABSTRACTION: Wrap Kite Connect or Fyers behind a strategy pattern interface with rate-limit queues and retry logic so you can swap providers in under 10 lines of code. I've built 4 low-latency trading systems for prop desks that process 50K+ orders daily without throttle violations. Let's schedule a 20-minute call to walk through your broker's API limits and position-sizing rules before we lock the architecture.
₹22,500 INR in 7 days
5.8
5.8

I will build this Python trading system for NSE equities/derivatives by integrating low-latency market data, market-making, and price-action signals into a clean, modular architecture. My approach: I will process order-book depth, trades, and ticks using an asyncio/websockets-based feed engine; derive fair value, micro-price, and momentum/breakout signals using NumPy/pandas; and rapidly amend or cancel orders via the broker interface. I will manage position sizing, max-loss limits, session P&L caps, and broker/exchange throttles within a separate risk layer. I will provide clean Python 3 code that includes audit logs for every decision/fill, unit tests, configurable broker adapters, and a VPS-ready README. 1. Which is the primary broker/API (Kite, Fyers, or IIFL)? 2. Which NSE instruments and trading sessions are being targeted? 3. What level of order-book depth is available in the market-data feed? 4. What are the VPS location and the expected latency target? I will verify the strategy and execution through paper/sandbox testing before delivering a production-ready system.
₹12,500 INR in 7 days
5.7
5.7

Bid Proposal for Python NSE Scalping Algorithm Hello, I'm Karthik, a Python developer with over 15 years of experience in algorithmic trading and financial systems. I specialize in building high-performance trading algorithms tailored for the National Stock Exchange (NSE). I can develop a Python-driven scalping system that seamlessly integrates market-making techniques with price-action signals, adhering to your requirements: 1. Real-time Data Handling: I'll implement a low-latency feed to subscribe to order book depth and trades. 2. Market Making & Price Action: The algorithm will calculate fair value, analyze candlestick patterns, and identify breakouts effectively. 3. Order Management: Orders will be placed, amended, and canceled in milliseconds while adhering to exchange limits. 4. Risk Management: I'll incorporate position sizing, max-loss stops, and P&L caps to minimize risk. 5. Logging: All actions will be logged for detailed analysis later. The code will be clean, well-documented, and utilize libraries like asyncio, websockets, pandas, and NumPy. I will ensure broker connectivity is modular for flexibility. Let’s chat further about your vision for this project! Best, Karthik
₹35,000 INR in 7 days
5.7
5.7

Hello, I can develop your Python based scalping and market-making system for NSE equities and derivatives. My approach involves using asyncio and websockets to stream real-time order-book depth and tick data with low latency. I will build an execution engine that quotes two-sided markets and monitors price-action breakouts, incorporating strict position sizing, stop-loss triggers, and session loss caps. I will abstract the broker API layer so you can easily switch between providers like Kite Connect or Fyers, set up local logging for all order fills and decisions, and provide modular unit tests along with a setup guide for your VPS or local machine. 1) Which primary broker API (such as Zerodha Kite Connect or Fyers) will you be connecting to initially? 2) Do you already have access to full Level 2 or Level 3 order-book market data feeds from your broker? Thanks, Bharat
₹35,000 INR in 12 days
5.3
5.3

Build a low-latency Python NSE scalping system combining order-book market making, price-action signals, broker abstraction, and strict automated risk controls. I can build the trading engine in modern Python using asyncio, websockets, NumPy/Pandas and a modular broker adapter, with separate market-data, strategy, execution, risk, persistence and monitoring layers. My relevant background includes Python, automated trading systems, NumPy/Pandas, WebSockets, PostgreSQL/MongoDB and software architecture. The execution layer would maintain live depth/trade state, calculate fair value and micro-price changes, generate two-sided quotes, evaluate momentum/breakout/candlestick conditions, and manage order amend/cancel/replace flows asynchronously. Risk controls would sit before order release, covering position sizing, max order value, exposure, session loss limits, open-order limits and emergency shutdown. NSE's current framework requires algorithmic orders to be appropriately identified and includes exchange surveillance around order-to-trade activity, so throttling and risk controls need to be designed into the architecture rather than added afterward.
₹25,000 INR in 7 days
4.4
4.4

With over five years of experience in backend development, DevOps engineering, and Kubernetes orchestration, I have the perfect skill set for building your Python NSE Scalping Algorithm. My proficiency in Python and its popular libraries such as asyncio, websockets, pandas, and NumPy aligns perfectly with your project's requirements. Additionally, my experience in integrating AI/ML solutions into applications means your trading system will benefit from modern techniques resulting in enhanced business outcomes. What sets me apart is my ability to build scalable and secure cloud infrastructures while keeping efficiency and speed at the forefront. The algorithms I develop respect exchange throttles and broker limits while placing, amending, and canceling orders within milliseconds - a crucial factor for live market data analysis. Moreover, my knowledge of applying position sizing, max-loss stops, and session P&L caps will ensure we keep risk tightly managed. Lastly, as an AWS-certified professional, I've equipped myself with skills like Infrastructure as Code (Terraform), Docker, Jenkins CI/CD that will be pivotal in deploying your algorithm on VPS or local machine quickly. Not only will you get clean code with clear comments but also a robust testing methodology to bring down perceived risks in adopting new broker APIs. I'm confident that my expertise, skills, and meticulousness make me the best fit for realizing your vision for Python NSE scalping algorithm.
₹37,500 INR in 7 days
4.3
4.3

As an experienced web and mobile app developer for over 9+ years, I am well-versed in Python coding and believe I can make your Python NSE Scalping Algorithm project a success. I have expertise in many of the tools and techniques you specifically mentioned such as asyncio, websockets, pandas, and NumPy. Moreover, my familiarity with E-commerce, CMS based websites and Logo design assures that I can provide clean interfaces for broker connectivity with popular choices like Kite Connect or IIFL. Since a low-latency feed is vital to your project, I will ensure my code focuses on optimizing speed so that it respects exchange throttles and broker limits without compromising the efficiency of the trading system. My extensive grasp on building systems for micro-price shifts and market-making techniques integrated with breakout patterns aligns with your project requirement. What sets me apart from other bidders is my commitment towards effective cost of the project and providing free after delivery support. I aim to build strong relationships with all my clients, providing them with quality work coupled with a positive experience. Choose me to bring your ideas to reality!
₹25,000 INR in 7 days
4.6
4.6

Most scalping briefs pick either market making or price action — yours runs both off one live order-book feed, so the quoting engine and the signal engine must share state without stepping on each other's fills. That shared-state design is the heart of this build. I would build one asyncio event loop: a websocket consumer ingesting tick, trade and depth data, feeding a fair-value quoter placing and amending two-sided orders inside exchange throttles, plus a price-action layer scanning candlesticks, breakouts and momentum. A separate risk engine enforces position sizing, per-trade stops and a session P&L cap. Broker access sits behind a clean interface — Kite Connect first, swappable to Fyers or IIFL — with every decision and fill logged to SQLite and flat files, plus pytest tests and a README for same-day VPS setup. Relevant experience: I have built e-commerce and marketplace systems with real-time order data and transaction-safe order flows, which maps directly to the fill-tracking and idempotency this bot needs. Two questions: which broker is the reference build, and can you share sandbox credentials? Should the first milestone be a paper-trading simulation mode before going live? If this sounds right, I am happy to walk through the architecture on a quick call before you decide.
₹32,500 INR in 14 days
4.4
4.4

Hi I can build the Python trading architecture around asyncio/WebSockets with clean broker adapters, real-time tick/order-book processing, configurable risk controls, and complete decision/order logging. My strongest experience is Python, real-time APIs, data processing and backend architecture; I can implement the market-making/price-action rules from your defined strategy without claiming proprietary trading expertise. Thanks Anshuman
₹25,000 INR in 20 days
4.4
4.4

Hi there, Your project "Python NSE Scalping Algorithm" instantly caught my attention — it's exactly the kind of work we love to take on. What stood out to me is how clearly you’ve described what you want — and clarity like that is where we deliver our very best work. From your brief I can see this involves ai — all areas we handle in-house. We specialise in C Programming, Python, Software Architecture, C++ Programming, which lines up directly with what you need. How we'd approach it: - Clarify the use-case, inputs and the exact output you expect - Build and integrate the model / automation pipeline - Evaluate accuracy and tune against real examples - Deploy with monitoring and a clear handover I’ll fold in your feedback fast and keep refining until the result feels exactly right to you. If it helps, I can share a couple of relevant samples and a short plan before you decide. Looking forward to it! Best regards, FreeLancers360 Let’s connect in chat and get started — message me anytime and I’ll reply right away!
₹12,500 INR in 7 days
4.0
4.0

I can build this NSE trading system in modern Python with a clean, broker-agnostic architecture designed for live market-data handling and disciplined execution. I have experience developing automated trading systems with Python, pandas, NumPy, WebSockets and broker APIs, including Bank Nifty options workflows with multi-timeframe signals, tick filtering, live data streams and automated order handling. I can structure the system around asyncio with separate modules for market data, order-book/fair-value calculations, price-action signals, execution, risk management, persistence and monitoring. The system can include: • Live depth, trade and tick subscriptions • Micro-price/fair-value and inventory-aware market making • Candlestick, breakout and momentum signals • Fast order placement/amend/cancel with throttle awareness • Position sizing, stop-loss and session P&L limits • Complete decision/order/fill logging • Broker adapter interface for Kite/Fyers/IIFL or another provider • SQLite/PostgreSQL or structured files for audit/research • Unit tests, configuration management and deployment README I can deliver this incrementally with a working market-data/execution foundation first, followed by strategy and risk modules.
₹35,000 INR in 7 days
3.7
3.7

Hi, I can build your NSE scalping system as a modular Python trading engine with real-time market-data processing, broker-independent execution, risk controls, and complete decision/fill logging. The best solution is to separate the system into market-data, strategy, execution, risk, and persistence layers. Live ticks/order-book updates can run asynchronously through websockets, while broker-specific logic remains behind a common interface so Kite, Fyers, IIFL, or another provider can be swapped without rewriting the core engine. The system can include: - Real-time tick/trade/order-book ingestion - Fair-value and micro-price calculation - Two-sided quote management - Price-action/breakout/momentum filters - Async order placement, amend and cancellation - Broker/exchange throttling controls - Position sizing and exposure limits - Per-trade and session loss limits - P&L monitoring and kill-switch logic - Full signal/order/fill audit logs - SQLite/PostgreSQL or flat-file persistence - Broker abstraction layer - Unit tests and deployment README I would first validate the system in replay/paper-trading mode, including disconnects, rejected orders, partial fills, stale-data conditions, and risk-limit breaches, before any live deployment. Once you share the target broker, instruments, expected tick volume, and exact strategy rules, I can confirm the implementation milestones. Best regards Ankit
₹35,000 INR in 7 days
3.8
3.8

As the founder of TechWagger, I emphasize on delivering custom software development solutions that are built for long-term growth. With a strong background in C Programming and Python, I'm uniquely positioned to develop the Python NSE Scalping Algorithm you've described. Our team at TechWagger brings extensive experience in developing trading systems and algorithms for various exchanges and markets. We understand the importance of speed, reliability, and flexibility in your algorithm. Our proficiency in Python's asyncio and websockets libraries combined with our understanding of broker connectivity - having worked with Kite Connect, IIFL, Fyers, among others - makes us well-equipped to handle complex order placing and manipulation tasks demanded by your project. Unit tests and strict adherence to modern software development practices such as comment-rich coding and clean interfaces are second nature to us at TechWagger. We understand how crucial it is for you to have a secure, efficient system running without disruptions. I can assure you that with our skills in Software Architecture matched with my expertise in Python 3, using popular libraries such as NumPy & Pandas we can deliver an innovative solution that not only meets but goes beyond your expectations.
₹37,000 INR in 7 days
3.0
3.0

Before strategy, the rules shape this design. Under SEBI's retail algo framework, an API strategy that crosses the broker's orders-per-second threshold has to be registered through the broker with an algo ID, run from a whitelisted static IP, and stay within exchange throttles. Constant quote-and-amend market making hits that limit fast, so the order engine needs a built-in rate limiter and an amend budget, or the broker blocks the session mid-day. The risk layer sits outside the strategy and can't be overridden by it: max position, per-trade stop, session P&L cap and a kill switch that cancels everything and flattens on breach or on a feed disconnect. asyncio feed handler for depth/ticks, micro-price and fair-value calc, price-action signals, paper-trading mode on the live feed before any real order, and every decision and fill logged. Which broker API: Zerodha Kite, Upstox, or another?
₹15,000 INR in 7 days
2.3
2.3

Hi I can build a modular Python 3 trading system with live NSE market depth/ticks, market-making + price-action logic, low-latency order execution, strict risk controls, P&L limits, and complete trade/decision logging. I’ll keep broker connectivity interface-based so Kite/Fyers/IIFL or another supported broker can be swapped easily, with asyncio, NumPy/pandas, unit tests, and deployment documentation. 1. Which broker/API and market-data feed do you currently have access to? 2. Should the first version support both equities and derivatives, or should we validate the strategy with one segment first? if looking for expert then lets connect (having UK , UAE and Country Experience)
₹35,000 INR in 7 days
2.1
2.1

Hello, I understand you need a Python-driven NSE scalping system combining market-making, order-book signals, and price-action strategies using live low-latency broker data. The goal is to build a modular, risk-controlled trading engine capable of fast order execution and detailed trade logging. Here’s what I can provide: • Async Python engine for live ticks, trades, and market depth, with fair-value/micro-price calculations, two-sided quoting, candlestick, breakout, and momentum signals. • Broker abstraction for Kite Connect, Fyers, IIFL, or similar APIs, with efficient order placement/amend/cancel handling and configurable throttling. • Position sizing, stop-losses, session P&L limits, comprehensive decision/fill logging, unit tests, README, and VPS-ready deployment structure. I bring over 4+ years of experience in Python, NumPy, Pandas, asyncio, APIs, data processing, and software architecture, with a strong focus on performance and reliable automation. Just to clarify a few things: • Which broker API and market-data feed will you use for NSE depth and tick data? • Should the first version run in paper-trading mode before live order execution? Please come to the chat box to discuss more about your project. Best regards, Indresh Kushwaha
₹25,000 INR in 7 days
1.6
1.6

Hello, The key challenge is building a low-latency trading engine where market-data handling, signal evaluation, order-state management, and risk controls remain reliable under rapid market changes. In particular, separating broker connectivity from the strategy layer is important so the system can be tested and extended without rewriting core logic. I have 5+ years of Python development experience with asyncio, WebSockets, NumPy, Pandas, API integrations, databases, and event-driven architectures. I can structure the system with independent market-data, strategy, risk, execution, logging, and broker-adapter modules. The implementation can include order-book/tick ingestion, fair-value calculations, configurable signal modules, position/risk limits, throttling, structured decision/fill logging, persistence, unit tests, and a clear README for VPS deployment. Idempotent order handling, reconnect logic, stale-data protection, and failure recovery will be considered so the system behaves predictably during feed or broker interruptions. I can also provide a paper-trading/backtesting mode first, allowing the complete strategy and execution pipeline to be validated before any live order-routing is enabled. Would you like the first milestone to prioritise the market-data/execution framework or the strategy and backtesting layer? Best Regards, Shailender
₹15,500 INR in 18 days
1.2
1.2

The market-making half of your spec is where retail setups lose money quietly. Through a broker API, tens to hundreds of milliseconds pass between a book change and your cancel reaching NSE, while co-located firms requote in microseconds. When price is about to move they pull first, so the resting order that gets filled is yours, just before the move goes against it. Two more limits. SEBI's retail algo rules cap an unregistered algo at 10 orders a second per exchange, and brokers reject the excess; quoting both sides gets there fast, and above it the algo must be registered through your broker. And broker feeds are snapshots, not every trade: Kite's full mode sends 5 levels of depth about once a second, so micro-price is an estimate. So price action is the core, and the market-making logic drives entries: rest at the touch when spread and micro-price favour it, cancel when the book turns, cross when the signal is strong. Broker access sits behind one interface, with an asyncio feed handler, an order manager throttled under the limit with acknowledgement checks, position sizing, max-loss stops, a session P&L cap and a kill switch. Every decision and fill goes to SQLite, with unit tests, a README and a paper mode on the live feed before real money. Background: ML-powered trading and forecasting systems, low-latency streaming pipelines, 8+ years of production Python. My rating here is 5 out of 5. How long do you expect to hold a trade: seconds, or a few minutes? Ronak
₹19,500 INR in 14 days
0.9
0.9

Ahmedabad, India
Payment method verified
Member since Oct 5, 2026
₹12500-37500 INR
$30-250 USD
₹12500-37500 INR
$30-250 USD
£750-1500 GBP
$250-750 USD
₹12500-37500 INR
₹750-1250 INR / hour
₹12500-37500 INR
$30-250 USD
₹750-1250 INR / hour
₹12500-37500 INR
min $50 CAD / hour
₹1500-12500 INR
$750-1500 USD
₹12500-37500 INR
$25-70 USD / hour
₹750-1250 INR / hour
€12-18 EUR / hour
$15-25 USD / hour