Fixing tradingview alerts not working reddit: Complete Guide

tradingview alerts not working reddit is a common search phrase for traders who rely on TradingView alerts and seek community fixes on Reddit. This article summarizes why alerts stop working, how Reddit users commonly diagnose the problem, step-by-step troubleshooting, webhook and Pine Script considerations, preventive best practices, and when to escalate to support. Whether your alerts aren’t sending push notifications, webhooks fail, or alerts trigger at the wrong time, this guide gives practical fixes and examples to get your workflow reliable again.

Why TradingView alerts fail — common causes

Alerts can fail for many reasons. Below are the most frequent root causes reported by users (including many posts across Reddit threads) and the quick explanation for each:

• Notification settings on device or browser — push, email, and browser notifications can be blocked or muted.
• Incorrect alert configuration — condition, frequency (“Once per bar close” vs “Once per bar”), symbol mismatch, or wrong timeframe.
• Pine Script / alertcondition misuse — the script doesn’t emit conditions correctly or the alert was created without the right condition.
• Webhook URL issues — insecure (http), wrong endpoint, missing SSL, or payload format not accepted by the receiving service.
• TradingView account/plan limits — too many active alerts or plan restrictions (frequency, SMS limits).
• Data feed and symbol differences — using different exchanges or tickers between chart and alert.
• Server-side delays or outages — TradingView or third-party services experiencing downtime or delays.
• Session / browser cache oddities — cookies, extensions, or stale sessions interfering with alerts creation or delivery.
• Timezone or session hours — exchange session or timezone mismatches cause alerts to appear off or not trigger during closed sessions.

Detailed troubleshooting steps (work through these)

Follow this ordered checklist to diagnose and fix most problems. Try each step and test alerts after completing it.

1. Check basic notification settings

   On your mobile device: ensure TradingView app notifications are allowed, background refresh is on, and battery optimization (Android) or Low Power Mode (iOS) isn’t blocking notifications.

   On desktop: make sure your browser allows notifications for tradingview.com and that system-level notifications aren’t disabled. Also verify TradingView > Profile > Notifications settings.

2. Verify the alert configuration

   Open the alert dialog and confirm:

   • The selected symbol matches the chart (e.g., BTCUSDT vs BTC/USDT on a different exchange).
   • The alert condition references the correct indicator or script output.
   • Alert frequency is set correctly — “Once per bar close” is different from “Once per bar” and can affect triggers during noisy price action.
   • Expiration date is still valid.

3. Recreate the alert (simple but often effective)

   Delete the problematic alert and recreate it from the exact script or indicator instance on the chart. Many Reddit users report this resolves transient issues caused by updates or session issues.

4. Check Pine Script alerts and conditions

   If your alert is tied to a custom Pine Script:

   • Make sure it uses alertcondition() for indicator-based alerts. If you rely on built-in signals in strategies, ensure the script exposes the proper alert conditions.
   • Test and log conditions using plots or labels to ensure they evaluate true when you expect them to.
   • For strategy alerts, be mindful that strategy.* functions behave differently from indicator.* functions — verify that the alert point is reached during backtest and live data.

5. Test webhooks with a known-good endpoint

   If using webhooks, confirm TradingView can reach the URL:

   • TradingView requires HTTPS endpoints — ensure a valid SSL certificate and correct HTTPS URL.
   • Temporarily use a public webhook testing service (e.g., webhook.site or RequestBin) to capture requests and confirm TradingView sends them.
   • Ensure the receiving server accepts the JSON payload format TradingView sends or adapt with middleware (e.g., a simple server that transforms payloads to Telegram/Discord webhook format).

6. Check account and plan limits

   Make sure you haven’t reached the maximum number of active alerts allowed by your TradingView plan. The plan may also limit SMS alerts, webhook frequency, or simultaneous alert counts.

7. Check exchange data and symbol mapping

   If you chart a symbol from Exchange A but set an alert on Exchange B’s symbol name, alerts may never trigger. Always match the chart’s symbol exactly.

8. Clear browser cache, disable extensions, or reinstall the app

   Session-related bugs happen. Clearing cache, using incognito mode, or reinstalling the mobile app can remove corrupt state and restore alert functionality.

9. Look for known platform outages

   Check TradingView status pages or their Twitter for outages. If TradingView is experiencing issues, you may need to wait until they resolve backend problems.

10. Contact support with diagnostic info

    If the alert still fails, contact TradingView support and include specific details (see “What to include in support requests” below).

Common Reddit-sourced fixes and why they work

Reddit threads on "tradingview alerts not working reddit" often share hands-on solutions. Here are several widely-cited fixes you’ll find on Reddit and the technical reason they help:

• Delete and recreate alerts — resolves stale server-side mapping between alerts and chart objects, especially after updates.
• Switch alert trigger option (“Once per bar” vs “Once per bar close”) — changes when the alert engine evaluates conditions and avoids false negatives caused by intrabar noise.
• Use alertcondition() in the script — ensures the alert is tied to a defined condition that TradingView can reference when creating an alert.
• Use a simple test alert on the same chart (e.g., price crossing a round level) — helps determine if the issue is global or script-specific.
• Check webhook service logs — many users find their webhook receiver rejects requests due to CORS, invalid tokens, or JSON format mismatches.

Webhook integrations — best practices and examples

Webhooks are powerful for sending alerts to bots, Discord, Slack, or your own automation. Common reasons webhook alerts seem to “not work”:

• Endpoint is HTTP (insecure) — TradingView requires HTTPS.
• SSL/TLS certificate errors on the server.
• Firewall blocks or IP restrictions on the receiver server.
• Incorrect JSON format or missing header expectations by the receiver.

Sample webhook JSON payload TradingView sends (simplified):

{
  "ticker": "{{ticker}}",
  "price": "{{close}}",
  "time": "{{time}}",
  "message": "{{strategy.order.alert_message}}"
}

Example steps to debug a Discord webhook:

1. Create a new webhook in a test Discord channel and copy the HTTPS webhook URL.
2. Use a webhook testing site (e.g., Webhook.site) to confirm TradingView sends a POST when the alert triggers.
3. If you see the POST at the test site but not in Discord, compare the payload formats. Discord expects {"content": "message"} — add a small intermediary HTTP script (or Zapier/IFTTT) to translate TradingView JSON into Discord’s required JSON.

Pine Script pitfalls that block alerts

Pine Script powers custom indicators and strategies, but small scripting mistakes block alerts:

• Not using alertcondition() for indicators. TradingView creates alerts based on alertcondition names.
• Using plotting-only logic without explicit alert conditions.
• Relying on repainting indicators or referencing future values — alert conditions may not evaluate consistently in live data.
• Creating alerts from a script that is not added to the chart instance used for the alert.

Quick Pine Script checklist:

• Create an explicit alert condition: alertcondition(condition, title, message).
• When creating the alert manually, choose the exact condition name from the alert dialog’s Condition dropdown.
• If using strategy.* functions for alerts, validate that the strategy reaches the order in live bars (strategy.* alerts behave differently than indicator alerts).

Account limits, SMS and push alerts

Check your TradingView plan. Free and paid plans have different alert quotas and capabilities:

• Free plans may limit the number of simultaneous active alerts.
• Higher-tier plans allow more alerts and faster webhook/push reliability.
• SMS alerts are limited by region and quota, and TradingView may throttle SMS delivery during high-load periods.

If you hit a plan limit, either upgrade or consolidate alerts using multi-condition scripts (use fewer alerts that evaluate multiple conditions) or use an external automation system that listens to fewer TradingView webhooks and performs logic downstream.

Timezone, exchange hours, and data lag

One subtle and common issue: alerts appear to trigger at the “wrong time” or not at all because of timezone or exchange data differences.

• Confirm the chart timezone (bottom right of the chart) matches your expectation.
• Different exchanges can have slightly different tick times and price feeds — an alert on BINANCE may not trigger if your chart is BINANCEUS and the instrument differs.
• Use “Last” or “Close” depending on whether you want intrabar or confirmed bar-close triggers.

Complete troubleshooting checklist (copyable)

1. Confirm notifications enabled on device/browser.
2. Open alert dialog — verify symbol, condition, timeframe, and expiration.
3. Delete and recreate the alert on the exact chart instance.
4. Test with a simple price-cross alert on the same chart to determine if global or script-specific.
5. If webhook, test with webhook.site; ensure HTTPS and valid SSL.
6. Check Pine Script: use alertcondition() and expose readable alert message placeholders.
7. Verify TradingView plan limits and active alert count.
8. Clear cache or try a different browser/device to eliminate session issues.
9. Check TradingView status pages for outages and platform updates.
10. Collect logs/screenshots and contact support if unresolved.

When and how to contact TradingView support

If you made it through the checklist and the alert still isn’t working, open a support ticket. Provide the following to speed diagnosis:

• Account username and plan level.
• Exact symbol and exchange (copy/paste from chart header).
• Screenshot of the alert settings dialog and the script’s code (if custom script used).
• Timestamp of expected trigger and evidence that the condition was met (chart screenshot with marker).
• Webhook URL you were attempting and a sample payload if possible.
• Steps you’ve already tried from the checklist.

Submit via the TradingView Help Center (https://www.tradingview.com/support/) and include attachments. Good detail helps engineers reproduce the issue quickly.

Advanced: routing TradingView alerts to Telegram, Discord, or order execution

Many traders use TradingView for signal generation and route alerts to messaging apps or to automated brokers. Best practices:

• Use a reliable intermediary service (AWS Lambda, Heroku, or a VPS) to receive TradingView webhooks and perform validation, retries, and transformations.
• Implement idempotent handling — TradingView may resend the same alert; your receiver should ignore duplicates.
• Maintain logs and retries for transient downstream failures (e.g., Telegram rate-limiting).
• Use secure tokens in the webhook path or Authorization headers to prevent unauthorized posts.

Example workflow: TradingView webhook -> AWS Lambda (validates and formats payload) -> Telegram Bot API or broker API. This reduces failures caused by format mismatches and improves deliverability.

Preventive best practices to avoid future alert failures

• Use explicit alertconditions in Pine scripts and descriptive alert messages with placeholders (e.g., {{ticker}} {{close}}).
• Keep your alert count manageable — consolidate logic into scripts when possible.
• Monitor status pages for TradingView and major webhook services.
• Use dedicated webhook endpoints with SSL, monitoring, and alerting on your server.
• Document and version-control your scripts so you can reproduce alert logic after updates.

Real-world example: fix reported on Reddit

Scenario: A trader on Reddit reported "alerts not firing" for a custom indicator after TradingView updated the platform.

1. They recreated the alert on the chart after confirming the script had an alertcondition.
2. They switched the alert execution from “Once per bar” to “Once per bar close” and the alert began working consistently on closes instead of on noisy intrabar ticks.
3. They also tested the webhook with webhook.site to verify TradingView reached their automation endpoint.

Outcome: Recreating the alert and matching the condition to a stable bar-close fixed the issue. This is a common pattern in community reports: small changes in alert creation or execution settings resolve persistent problems.

Further reading and resources

• TradingView Help Center — official support articles and status updates.
• TradingView (Wikipedia) — background on the platform.
• Pine Script documentation — official guide for alertcondition and script behavior.
• Webhook.site — test endpoint to capture and inspect webhooks quickly.

Related crypto resources (useful for setting symbol alerts)

If you’re using TradingView alerts for cryptocurrencies, you may find these in-depth articles helpful when selecting symbols or learning more about assets you monitor:

• What is ETH in TradingView — an in-depth guide — practical for setting accurate Ether alerts and symbols.
• Ethereum price prediction 2026 in Rupees — analysis and forecasts — helpful background when creating longer-term price alerts.
• What is Bybit Exchange Coin — token overview — useful if monitoring exchange-native tokens on TradingView.
• Is Binance Coin Halal — Islamic perspective on cryptocurrency investment — for traders considering ethical or region-specific considerations when setting alerts on BNB.

Summary — make your alerts reliable

Most "tradingview alerts not working reddit" complaints boil down to configuration, Pine Script issues, webhook problems, or device notification settings. Work methodically through the checklist: verify settings, recreate alerts, test with simple conditions, validate webhooks with webhook.site, and ensure Pine scripts expose alertcondition() calls. If those steps fail, gather clear diagnostic information and contact TradingView support.

By following the practical steps and best practices above, you’ll reduce surprises and make your TradingView alert system robust — whether you’re monitoring ETH price swings, Bybit coin movements, or broader market signals discussed across communities like Reddit.