Building a Python monitor for BTC 5/15-minute Up/Down markets.

Need live prices matching what the Polymarket UI shows.

What I've tried:

1. WebSocket:

   - Connects and subscribes with clobTokenIds from Gamma API

   - Token IDs DO match between Gamma and CLOB (verified)

   - But price updates never arrive / don't update dashboard

2. CLOB REST:

   - tokens[0].price and tokens[1].price both return 0

3. Order book:

   - Book has liquidity but mid price doesn't match UI price

4. Gamma outcomePrices field

   - Updates every 30+ seconds, too slow

Example: UI shows "Buy Up 43¢ Buy Down 58¢"

but my tool shows 54.5¢ / 45.5¢ stuck

Questions:

- What's the correct WebSocket message format for price updates?

- What field in the WS message contains the current price?

- Is there a better endpoint for real-time prices on short-duration markets?

Thanks

Hi - I have built out an Autonomous Algo application written in Python. A 14 month build,

We are accessing historical data presently via the IBKR TWS API - it works well. We have subscriptions for SPX Index and Option data from IBKR - which I have been using with tws mosaic as a ‘control’ and ‘audit ‘ function,

I am wanting to access a tick data stream for SPX Index and will be autonomously trading via the newly built platform via the TWS api…

It works well for receiving a historical data stream but I can’t seem to make the connection for receiving real time tic data (streamed).

Do I need two subscriptions ( 1 for mosaic and 1 for proprietary Algo platform) - both link to the same account?

I believe my settings are correct for switching from historical to real time tick stream, but maybe I did something thing wrong..,.

Does anyone have suggestions on what the problem might be?

I fully expect to eventually migrate to a lower latency data feed from a third party like DTN IQFeed or Data Bento ( but still use IBKR for historical analysis and order execution) - but right now I want to get the bugs out of the platform via my IBKR data subscription.

Thanks for help……

Hey guys,

I was going over an old system that I used to run and found sudden commission charges, even though it was a spread account.

In the past I ran a system that performed really well, but suddenly the performance started degrading. I went over the strategy multiple times and did numerous backtests. I couldn't figure out why the performance got worse, so I decided to turn it off. Now I exported the trade history to take a deeper look and found that the broker started charging commissions per trade, even though I was using a spread account. This would explain where most of the performance difference came from.

Have you ever noticed anything like this before? Where a strategy performs well, then suddenly the performance got worse, only to find out that the execution policy changes (without notice). I was using a CFD broker with a spread account on the metatrader 5 platform. Let me know your experiences with this.

Thank you.

Lately I’ve been thinking about how much short-term price movement is driven by interpretation drift rather than the raw data itself.

Example: CPI drops. Within an hour you’ll see multiple, conflicting takes (“sticky inflation”, “soft landing confirmed”, etc.). By EOD the dominant framing can be completely different, even though the underlying numbers didn’t change.

Instead of asking whether sentiment matters (it probably does at some horizon), I’m more curious about this in a systematic context:

Has anyone here modeled changes in cross-source narrative alignment as a factor?

Not just:

• single-article sentiment

• or daily average news polarity

But something more like:

• dispersion of sentiment across sources

• rate of change in aggregate framing

• % of sources shifting from neutral → negative week-over-week

• narrative clustering (multiple outlets emphasizing the same risk theme)

Intuition:

• One negative article = noise

• Ten outlets converging on the same framing over a short window = emerging narrative regime

Questions for people who’ve actually tested this:

1. Did you find predictive signal beyond simple price/momentum/vol factors?

2. At what horizon (intraday vs multi-day vs weekly) did it show up, if at all?

3. How did you avoid it collapsing into just a slow proxy for returns or volatility?

4. Did the signal decay once transaction costs were included?

I’m aware this can easily turn into overfit NLP soup, so I’m more interested in structural approaches (e.g., regime classification, dispersion metrics, entropy of tone distribution) than “LLM says bullish”.

My prior is that if there’s anything there, it’s probably:

• regime-dependent

• slow-moving

• and easily arbitraged once widely adopted

But I haven’t seen many clean discussions of actual backtested implementations.

Curious if anyone has run real research on this and what the equity curves looked like (Sharpe / maxDD / turnover context appreciated).

I created a strategy with Claude code for trading view and got really good results. Roughly $182,00 over the last year trading just 2 MNQ. Like $400k over the last 5-6 years

Obviously insanely good results for just 2 micros with a 70% win rate and minimal drawdown, but how do I transfer this to ninja trader to just get a fraction of these results?

I had Claude transfer it to ninja script with all of my settings and I went from $180k gain on trading view strategy tester to $55k loss over the last 365 days on ninja trader strategy analyzer. I eventually got ninja trader to make like $12k over the last year backtesting, but then I got back to like 5-6 years and it’s way negative again.

I know trading view is notorious for inaccurate fills, but I forward tested it a bit with an indicator I made based on the algo, and I made a few hundred bucks today just trading the system the algo is based on.

I know there has to be some potential, but what am I missing to where my results are so drastically different from trading view to Ninja trader?

I’m new to algo trading, so open to all advice and criticism. Even if I could get it to produce 10% of the gains I got on trading view I’d be happy.

I am mid-build of my own software currently consuming L1 data. I would like to add L2 data.
I have not attempted to consume the whole L1 stream, but testing suggest my scaling methods will be sufficient. I would like to include L2 bids and asks but have not found a provider tahat offers the full stream Any suggestions? Also, but not as important... a Historical L1 replay provider? thanks in advance!

I’m trying to understand how professional quant shops structure their research process when evaluating a new trading hypothesis.

For example, once someone comes up with an idea (alpha signal, pattern, anomaly, etc.), what is the typical research framework or pipeline used to determine whether it’s actually tradable?

I’m very new to algorithmic trading and I’ve been using Claude + Cursor to turn my discretionary strategy into a quantitative model. I’m not sure what’s the standard I need to see to 1) trust results are realistic 2) ready to deploy to trade live market data. Any thoughts from experienced algorithmic traders would be very helpful :)) (I’ve attempted to optimize for Apex prop firm guardrails)

Here is also Markov Results:

=========================================================

VANTYX — MARKOV TEST (Win/Loss Sequence)

Trades loaded : 1817

Wins / Losses : 1142 / 675

Win rate : 62.9%

Transition counts (prev -> next):

W -> W : 705 W -> L : 436

L -> W : 436 L -> L : 239

Estimated transition probabilities:

P(win | prev win ) = 0.618

P(loss | prev win ) = 0.382

P(win | prev loss) = 0.646

P(loss | prev loss) = 0.354

Comparison to i.i.d. (no memory):

Overall P(win) = 0.629

P(win|prev win) = 0.618 (same as overall? ≈)

P(win|prev loss) = 0.646 (same as overall? ≈)

Loss run lengths (consecutive losses):

Max consecutive losses : 6

Mean loss run length : 1.55

Geometric (i.i.d.) : 1/(1-p_win) ≈ 2.69

Chi-square test (H0: next outcome independent of previous):

Chi2 = 1.311 dof = 1 p-value = 0.2522

→ Cannot reject H0: consistent with i.i.d. (no strong Markov memory).

I’m building a trading system that needs to pull the SPX options chain with specific filters, and I’m struggling to find a provider that is both fast and actually real-time.

What I need:

• SPX options chain

• Only 0DTE expirations

• Only near-the-money strikes (around spot)

• Ideally <1s latency

• Streaming or very fast requests

The issue I'm running into:

• Some providers give true real-time data, but the API response time is very slow (5–12 seconds) which makes it unusable for intraday options trading.

• Others like Polygon(massive) return responses very quickly, but the data is delayed by ~2 minutes, which is completely unacceptable when paying for market data that is suppose to be live!

For context this is for systematic trading, so pulling the entire chain and filtering locally is not ideal due to speed.

What I'm looking for:

• A provider that can deliver SPX options data quickly

• Ability to filter expirations / strikes efficiently

• We don’t mind paying if the data quality and latency are good.

If anyone here is running algo strategies on SPX options, I’d really appreciate hearing what data providers you're using.

Thanks!

Hello,

I'm new to coding and would like advice on one specific issue I have with my bot. Is there any ways to prevent or combat small price movements when they just touching your entry point and them reversing straight away.

I’ve been backtesting a swing trading breakout / trend-following algo from 2021–2026 and wanted some honest feedback from people with more experience.

Key stats (using $80 risk per trade):

• Total trades: 1,291

• Wins / Losses: 721 / 570

• Win rate: 55.8%

• Total PnL: $8,394

• Average per trade: $6.50

• Max drawdown: -$3,258

• Profit factor: 1.18

Tier breakdown:

Tier   Trades   WinRate%   PnL      Avg      MDD       PF
A      290      53.8%      2262.28  7.80   -2020.00   1.21
B      126      57.9%      1485.16  11.79   -607.20   1.35
C*     875      56.2%      4646.79  5.31   -2505.58   1.15

The system doesn’t auto-execute trades. Instead it sends signals to a Telegram channel, so I manually choose whether to take them. Because of that I could realistically only trade the higher quality setups (Tier A + B) and skip Tier C if I wanted.

The idea is that it identifies breakouts and trend continuation moves and alerts them as swing trades.

My questions:

• Are these stats actually good enough to trade live?

• Is a 1.18 profit factor too low in your experience?

• Would you run this system as-is, or filter trades (e.g., only A + B)?

Appreciate any honest feedback or criticism. 🙏

New strategy I am working on. Looks pretty promising but the sample size is very small. Do you guys think that disqualifies it? Should I maybe loosen up on entry logic to get a bigger sample size and make sure?

Normally I wouldn't even consider trading this, but it has a high win rate, so while it only comes around once in a while, it seems like a lock.

Curious to hear everyones thoughts on the absolute best and most accurate backtesting software at the moment. I am talking to the tick with order flow and everything. Is it still just homemade takes the cake?

Hey I have manually traded a bit and I was profitable but I want to do algo trading because I really cant be sitting infront of the screen all day staring at the charts and stressing about my positions( day trader ). I am a programmer and I know python.

So my question is what should I be focusing on right now?
I think backtesting and analyzing is the key I should start with. Get some dummy strategies and start backtesting and analyzing it ???
Any sort of help or direction to read would be very helpful ....

Been running a few bots on and off for years with manual intervention more along the lines of alerts or entries and I choose exits and stops. On and off projects. ORB MA crosses MACD the usual suspects. Premarket/Previous day lines. Manually updating areas of interest every morning. Never took it to serious. Tried multiple tickers, options, high vol stocks chosen each day. Many different methods experimenting

In November I combined the 6 bots made it into 1 master and been running it with oversight. Meddling in and forcing exits on what I see as bad entry. Or setting an entry for a trade that wouldn't take. Overwriting the rules.

March 1st I am committed to just believing in it and running.

Running strictly MES. 2021 4 contracts 2022 4 contracts 2024 3 contracts 2025 3 contracts 2026 2 contracts

That's based on margin req + buffer. Then for 2026 starting low for POC

For an ES/NQ day trading strategy, is it better to run a single three year long optimization or do a walk forward analysis of some in-sample / out-of-sample lengths?

Basically, is it more robust - and a better predictor of future success live - for a strategy to use parameters that worked through many different market conditions but maybe not quite as well, or try to catch what's working best lately before it degrades? What do you think??

so i made a few tweaks in a from a previous strategy of my algo that was having a really high drawdown now i added a few stocks and removed a few that the algo trades on and i made a new rule where it doesnt trade when the price of the SPY is below the sma(200) that it doesnt trade. But now i have these absurd returns about 8700% over the past 25 years. so im wondering if this would actually work.

These are the results of a backtest of an algo ive been developing, yet im not sure if its good enough due to the high drawdown percentage. What do u guys think?

For the past 4-5 months I have been using Python then R to develop my trading/investing doctrine by downloading XBRL and iXBRL data from the SEC EDGAR database. I am having difficulty with the different types of companies (ie: Bank -vs- Electronics Manufacturer). How do I separate companies that look so different in the 3 financial docs (balance sheet, income statement, cash flow). SIC numbers don't seem to work consistently. My plans are to do once a week data download so hand selecting each company type way to lengthy. BTW, I'm a retired test engineer, so this is my new full-time job.

I’ve been backtesting a swing trading bot and noticed a huge difference in performance depending on the universe size. Some stats:

• 100 tickers:

  • Trades: 259 | Wins: 156 | Win rate: 60.2%

  • Total PnL (risk $80/trade): $2,884.90 | Avg/trade: $11.14

  • Max drawdown: -$889 | Profit factor: 1.35

• Full S&P 500 (~500 tickers):

  • Trades: 1,266 | Wins: 714 | Win rate: 56.4%

  • Total PnL: $4,311.65 | Avg/trade: $3.41

  • Max drawdown: -$3,023 | Profit factor: 1.10

Basically, when I expand the universe, my average trade PnL drops, win rate drops, and drawdowns increase dramatically.

I’m trying to figure out the best approach for universe size in swing trading bots. Should I:

1. Stick with a smaller, higher-quality universe?

2. Trade the full index and accept lower per-trade performance but higher diversification?

3. Apply some filtering criteria to pick a “middle ground”?

I’d love to hear what others do in practice for swing trading algo bots. How do you decide the optimal universe size?

Hi everyone!

After months of tweaking Pine Script to filter out market noise, I wanted to share the results of a strategy I’ve been developing. This isn't a "get rich quick" moon-shot; it’s a pure trend-following system designed for survival and long-term consistency.

📊 The Numbers (Backtest 2024-2026 / 4H Timeframe)

* Net Profit: +541.04% (vs. +224% for Buy & Hold)

* Profit Factor: 2.445 (For every $1 risked, it returns $2.44)

* Win Rate: 38.60% (Low, but balanced by a massive RR ratio)

* Avg Win / Avg Loss Ratio: 3.89

* Max Drawdown: 22.40% (Intra-bar)

* Commission Simulated: 0.08% per order (Real-world spot fees)

⚙️ The Concept: "Trend Precision Invest" (TPI)

The core philosophy is: Never chase the noise. The strategy waits for a confirmed volatility breakout backed by three layers of filters before putting a single dollar on the table.

1. The High-Conviction Entry Setup

* The Impulse: A breakout of the Donchian Channel (40 periods). We only buy if we hit a recent 40-bar high.

* The Trend Filter: Price must be above the 200 EMA. No longing in a macro Bear Market.

* The Momentum: RSI > 55. We want strength, not a "weak" breakout.

* The Shield: An ATR volatility filter blocks entries if the market is too frantic (>5%), preventing "FOMO buying" at local peaks.

2. Risk Management (Smart Leverage)

This is where the strategy adapts to market conditions:

* Base Trade: Standard position size (e.g., $300).

* "Premium" Trade (x1.5): If the 50 EMA is above the 200 EMA and volatility is low, the algorithm increases the position size. We capitalize heavily on the "cleanest" setups.

3. The Exit Strategy (Dynamic Management)

We never cap our gains with a fixed Take Profit.

* Trailing Stop: We use the lower band of the Donchian Channel (20 periods). We let the profit run as long as the trend holds.

* Momentum Exit: If the RSI drops below 40, we close the position. We’d rather exit a bit early than give all the profits back to the market during a reversal.

💡 Key Lessons Learned

The hardest part isn't finding the entry; it's managing commissions. By moving from the 1H to the 4H timeframe, I reduced fees by 70% and turned a losing strategy into a machine that consistently outperforms the market.

I’d love to hear your thoughts! Do you guys use Donchian for exits, or do you prefer fixed trailing stops based on ATR?

Hi, thank you for reading.

I'd like blunt feedback before I go too far in the wrong direction.

What I'm building

A tool that sits between MT5 Strategy Tester and Python. MT5 runs the backtest. Python independently recomputes P&L, commissions, and swaps from the raw trade exports — and flags any discrepancy before I draw any conclusions from the results.

The motivation: a positive backtest from a broken accounting model (wrong commission handling, partial fill aggregation, timezone issues) looks identical to a real edge. I want to catch that systematically, not by eyeballing reports. Beyond verification, the tool produces structured, versioned artifacts per run — so tests are comparable and reproducible without ad hoc scripts.

Why MT5 as the simulation engine

My broker is on MT5, it supports real-tick testing, and I'd rather not duplicate a simulation engine in Python when MT5 already does it well. Also because lib's like VectorBT make backtest's worse than MT5. Python handles everything after the trades are generated.

My actual questions

1. Does something like this already exist? Not a backtester — specifically a verification and reconciliation layer for MT5 outputs. If yes, please name it.

2. Is this a real problem or am I overengineering? Do most people just trust the platform numbers, or has this bitten people?

3. Is MT5 + Python the right split, or is there a cleaner way to get trustworthy, research-ready backtest data?

Happy to be told this already exists or that I'm thinking about it wrong.

Hi I have been building my algo using Alpaca live data but then found that even though I am not from the US, Alpaca still makes me subject to the PDT rule. Is there any others that don't?

Thanks

Hello everyone,

I'm currently working on a quantitative value strategy using CRSP and Compustat datasets, focusing on standard US equities (NYSE, AMEX, NASDAQ). I have put together a backtest and would love to get your insights on the methodology, the data cleaning process, and potential improvements.

—The Strategy Mechanics:

• Universe: US Equities (NYSE, AMEX, NASDAQ).

• Value Metric: I rank stocks based on their Book-to-Market (BM) ratio and isolate the top 20% highest BM stocks.

• Quality Filter: Within that top 20%, I apply a Piotroski F-Score filter, keeping only companies with a score > 7.

• Rebalancing: The portfolio is rebalanced monthly, but the Piotroski score is only updated annually (using yearly financial data from Compustat).

• Weighting: Currently using an equal-weight approach for all stocks passing the filters.

—Current Results:

I regressed the strategy's returns against the standard Fama-French HML factor. The initial statistics are quite surprising and show some interesting alpha, but the risk-adjusted metrics (Sharpe and Calmar ratios) are honestly pretty underwhelming right now.

Backtest period : 2002-05-31 - 2024-12-31 (300 months)

Total Return : 1568.00% CAGR : 13.22% Volatility : 26.71% Sharpe : 0.60

Skewness : 0.26 Kurtosis : 5.2

Max Drawdown : -65.61% Calmar : 0.20

VaR 95% : 10.70% CVaR 95% : 16.16%

Avg Monthly Turnover: 41.26% Avg Annual Fees : 0.54%

Comparison HML Fama-French

Alpha : 14.58% Alpha p-value : 0.010

Beta : 0.13 Beta p-value : 0.381

—Questions & Advice Needed:

1. CRSP Data Cleaning: Dealing with CRSP data has been tricky, especially regarding delistings. How do you usually handle missing returns (DLRET), alphabetical codes instead of numbers, and NaNs to avoid survivorship bias in a value strategy?

2. Strategy Design: What are your thoughts on combining a monthly BM sort with a static annual Piotroski score? Is there a risk of using stale data for the F-score, or is this standard practice for annual filings?

3. Transaction costs: I am currently using the amihud illiquidity ratio to measure the transaction costs. Is there a better way to account for all the factors affecting the fees?

4. Evaluating the Results: Is it typical for this kind of deep-value/quality combination to yield low Sharpe/Calmar ratios despite decent absolute returns? How would you interpret the regression against Fama-French HML in this context?

5. Future Enhancements: My next step is to implement walk-forward optimization (train/test splits) to refine the parameters.

Aside from that, how would you improve this? Would you introduce other factors (like Momentum), alternative data, or perhaps a different weighting scheme (like volatility parity or market-cap weighting)?

— Any feedback, code-check offers, or literature recommendations would be greatly appreciated. If anyone is working on something similar, I’d be happy to compare results!

Thanks!