How Many Scripts Can You Publish on TradingView? Limits and Rejections

How many scripts can you publish on TradingView? From what I measured while publishing 17 original scripts across three batches in 2026, the platform enforces two rolling caps on public scripts: five per 24 hours, and fifteen per rolling thirty days. Hit either and the publish dialog refuses until the window reopens. Private scripts and private ideas are not counted the same way, and the limits are not documented in a single place, which is why people discover them the hard way with a sixth script ready and nowhere to put it.

What gets rejected is a separate question, and it is the one that actually costs accounts. Moderation on TradingView is about the description and the presentation, not the code quality. This post covers both: the publish limits I measured, the house rules that trigger a takedown, and how I built a toolkit that stages every publish in a compliant shape before a human presses the final button.

What are the exact TradingView publish limits?

Measured on a standard account during three publish batches:

• Five public scripts in any rolling 24-hour window. The sixth attempt is blocked at the dialog.
• Fifteen public scripts in any rolling 30-day window. My third batch staged its scripts and then waited for slots to reopen.
• Updates to an already published script do not appear to consume a slot.
• The windows are rolling, not calendar-based, so a script published at 13:00 frees its slot at 13:00 the next day, not at midnight.

Because these are measured rather than documented, treat them as current behaviour that can change. I encode them in my scheduler as parameters, not constants, so a changed limit is a one-line edit. TradingView's own house rules for scripts are at https://www.tradingview.com/house-rules/ and should be read in full before publishing anything.

What does TradingView moderation actually reject?

Moderators read the description and look at the chart screenshot. The reasons I have seen scripts removed or flagged, mine and others':

• A description that does not explain what the script does and how it differs from existing scripts. "Buy when green, sell when red" is not an explanation. Originality is judged on the description.
• Performance language: win rates, accuracy percentages, profit claims, "never loses", or any wording that implies guaranteed results.
• Promotional content: links to paid services, contact details, or calls to join a group. For open-source scripts, even soft promotion is risky.
• Screenshots that are unreadable, cluttered with other indicators, or show a different script than the one published.
• Low-effort republishing of a common indicator with cosmetic changes.
• Vendor rules for invite-only scripts, which are considerably stricter and not covered here.

The pattern is that moderation enforces usefulness and honesty to other users. A script that explains its logic plainly, shows a clean chart and makes no claims is almost never a problem.

How do you write a description that passes moderation?

My template, developed over 17 publishes with no rejections:

1. One paragraph on what the script does, in plain language.
2. A section on how it works: the inputs, the calculation, the signals, described without code.
3. What is original about it, stated specifically (a new combination, a different normalisation, a verification method).
4. How to use it: timeframes and markets it was tested on, which inputs matter.
5. Limitations and honest caveats, including that signals are not advice and that no accuracy is claimed.
6. If applicable, a short note on verification (for example, that counts were checked against a Python reimplementation).

No links, no performance numbers, no exclamation marks. A rule I added after building an ideation skill from 134 open-source scripts by a well-known author: no accuracy or edge claim appears anywhere unless a statistical probe with a shuffled baseline flags a real edge, and even then it is stated as a measurement with its conditions.

Should you automate publishing, and what can go wrong?

Publishing one script properly takes a dozen steps: create a fresh script without touching your open draft, load source, save, add to chart, verify it actually plots, write the description, pick categories, tick the house-rules acknowledgement, and publish. Doing that five times in a day by hand is error-prone, and the errors are the kind moderation notices: wrong screenshot, description pasted into the wrong script, category left at default.

Automation over the desktop app's DevTools Protocol removes those errors, but it has its own traps I had to solve:

• Clicks only land in the tab that is actually fronted; a hidden tab accepts keystrokes but not clicks.
• The add-to-chart chord must be a real keyboard chord sent to the editor, not a synthetic event.
• The open-script dialog must be freshly opened each time; a stale dialog finds the wrong script.
• The publish window opens asynchronously, so the driver polls for it rather than waiting a fixed time.
• Everything runs in a scratch layout pinned for publishing so the owner's working chart is never modified.

How do you verify a script works before publishing it?

Compiling is not verification. A script can compile and plot nothing, or plot the wrong series. My verifier adds the script to a chart and reads back plot values and table cells over the DevTools Protocol, then compares them with expected numbers from an offline reimplementation. For strategies, an optimiser drives TradingView's own engine through the study input API at about two seconds per parameter combination, splitting in-sample and out-of-sample by trade exit time, so the published default settings are chosen on the out-of-sample half. For signal indicators, a numba-based stop-and-reverse optimiser on exported bars matched the on-chart signal counts exactly before any default was fixed.

How I built this: the TradingView Auto-Publish Toolkit

The TradingView Auto-Publish Toolkit automates the whole flow against TradingView Desktop over the DevTools Protocol and encodes the limits above. Its workflow per script is:

1. The idea is drafted and compile-checked offline with a Pine checker before anything touches the app.
2. A staging script creates a new script in the scratch layout, loads the source, saves it and adds it to the chart.
3. For strategies, the optimiser grids inputs through TradingView's tester with an IS/OOS split; for indicators, the numba optimiser runs on exported bars.
4. The verifier reads plots and table cells back to confirm real output.
5. A publish script fills the description from the template, selects categories, ticks the house-rules box and stops at the final button for review, or publishes when the batch is approved.
6. A scheduler spaces publishes to respect five per day and fifteen per thirty days, and queues anything beyond the window.

Design decisions: offline compile first, a dedicated layout, numeric verification as a gate, template descriptions with a no-claims rule, and platform limits as scheduler parameters. The outcome was 17 original scripts published across three batches (six trend-following, six data-driven originals, five famous-trader method indicators with a journal layer) with zero moderation rejections, plus a scheduled sixth script that waited for its slot automatically. The journal layer from the third batch is described in how to add SL/TP lines and a trade journal table to an indicator, and the compile-first discipline comes from why AI-generated Pine Script won't compile.

FAQ

Do private scripts count toward the publish limit?

In my experience the caps applied to public publishes. I did not measure private publishing at volume, so treat private limits as unknown rather than unlimited.

Can a rejected script be fixed and republished?

Usually a moderator's note tells you what to change, and an updated description or screenshot resolves it. Repeated violations escalate, so fix the description template rather than the single script.

Is open-source or protected better for moderation?

Open-source scripts are held to the originality and description standard. Protected and invite-only scripts add vendor requirements. For free educational publishing, open-source with a thorough description has been the smoothest path for me.

Does automation violate TradingView's rules?

The toolkit automates my own keyboard and mouse actions in my own desktop application, publishing scripts I wrote, within the platform's limits. It does not scrape, spam or circumvent anything. Read the house rules yourself and keep a human in the loop at the final step if you have any doubt.

If you want a verified, compliant publishing pipeline for your own scripts, tell me about it on the contact page.