Beispiele

Jedes Beispiel auf dieser Seite ist ein vollständiges Script. Kopiere es in den Editor, klicke auf Ausführen und mit Zum Chart hinzufügen legst du es in den Chart. Die ersten fünf sind die eingebauten Vorlagen, die du auch über Vorlagen im MantaAi-Panel lädst.

Delta-EMA

Glättet das Volume Delta mit einem EMA und zeigt es als Histogramm. Balken über null heißen: In diesen Kerzen haben aggressive Käufer überwogen, darunter aggressive Verkäufer.

// CoinScript · Delta-EMA
const len = input('Länge', 21)
const d = ema(delta, len)
plot(d, { title: 'Delta EMA', color: '#00FFDA', style: 'hist' })
hline(0)

• Zeichnet in ein eigenes Fenster, positive Balken türkis, negative rot.
• Länge stellst du in den Einstellungen des Fensters unter Eingaben ein.
• Das Delta kommt vom Taker-Volumen, siehe Sprache. Für Symbole ohne Order Flow bleibt das Fenster leer.

CVD-Divergenz

Markiert Kerzen, bei denen Preis und CVD auseinanderlaufen, und zeichnet den CVD in ein eigenes Fenster.

// CoinScript · CVD-Divergenz
// Preis macht ein neues Hoch, CVD nicht (und umgekehrt)
const len = input('Fenster', 20)
const pHi = highest(high, len), cHi = highest(cvd, len)
const pLo = lowest(low, len), cLo = lowest(cvd, len)
const bear = close.map((_, i) => i > len && high[i] >= pHi[i] && cvd[i] < cHi[i - 1])
const bull = close.map((_, i) => i > len && low[i] <= pLo[i] && cvd[i] > cLo[i - 1])
signal(bear, { title: 'Bearish', color: '#FF1919', pos: 'above' })
signal(bull, { title: 'Bullish', color: '#00FFDA', pos: 'below' })
plot(cvd, { title: 'CVD', color: '#FFFCF0' })

So liest du es:

• Bearish (rotes Dreieck über der Kerze): Das Hoch der Kerze ist das höchste der letzten 20 Kerzen, der CVD liegt aber unter seinem bisherigen Hoch. Der Preis steigt, ohne dass Käufer nachlegen.
• Bullish (türkises Dreieck unter der Kerze): umgekehrt am Tief.
• Im Backtest wird Bullish zum Long- und Bearish zum Short-Einstieg.

Funding-Extrem

Normiert die Funding Rate als Z-Score, also als Abstand vom Durchschnitt der letzten Kerzen in Standardabweichungen. Werte über 2 oder unter −2 gelten als extrem: Die Funding Rate ist dann ungewöhnlich hoch oder ungewöhnlich niedrig.

// CoinScript · Funding-Extrem
const z = zscore(funding, input('Fenster', 48))
plot(z, { title: 'Funding Z', color: '#FFEB3B' })
hline(2, { color: '#FF1919' })
hline(-2, { color: '#00FFDA' })

• Funktioniert nur auf Krypto-Perpetuals.
• funding verläuft in Stufen und reicht etwa 1.000 Kerzen zurück, davor bleibt die Linie leer.
• Das Fenster zählt Kerzen. 48 Kerzen sind im 1-Stunden-Chart zwei Tage, im 4-Stunden-Chart acht.

EMA-Band

Zwei EMAs direkt im Preischart, Kreuzungen als gelbe Marker.

// CoinScript · EMA-Band auf dem Preis
const fast = ema(close, input('Schnell', 21))
const slow = ema(close, input('Langsam', 55))
plot(fast, { title: 'EMA 21', color: '#00FFDA', overlay: true })
plot(slow, { title: 'EMA 55', color: '#FF1919', overlay: true })
signal(cross(fast, slow), { title: 'Kreuzung', color: '#FFEB3B', pos: 'below' })

cross() erkennt beide Richtungen, alle Marker sitzen unter der Kerze. Für den Backtest sind das deshalb nur Long-Einstiege. Eine Fassung mit getrennten Richtungen findest du weiter unten unter „EMA-Kreuzung als Strategie“.

Umsatz gegen Kurs

Für Aktien: Umsatz und Gewinn des Unternehmens als Linien in einem eigenen Fenster mit eigener Skala, unter dem Kurs. Ein gelbes Dreieck markiert jeden Bericht, bei dem der Umsatz höher ist als beim letzten Bericht, der Kurs aber seitdem gefallen ist.

// CoinScript · Umsatz gegen Kurs
// Aktien: Umsatz und Gewinn in Mrd. im eigenen Fenster. Markiert jeden Bericht
// mit mehr Umsatz als beim letzten, vor dem der Kurs seitdem gefallen ist.
const zwoelf = input('12 Monate (1) oder Quartal (0)', 1)
const umsatz = zwoelf ? revenueTtm : revenue
const gewinn = zwoelf ? netIncomeTtm : netIncome
plot(umsatz.map(v => v / 1e9), { title: 'Umsatz (Mrd.)', color: '#00FFDA' })
plot(gewinn.map(v => v / 1e9), { title: 'Gewinn (Mrd.)', color: '#FFFCF0' })
hline(0)
const treffer = close.map(() => false)
let letzter = -1
for (let i = 1; i < bars; i++) {
  // Ein neuer Bericht: der Wert ändert sich an diesem Tag.
  if (Number.isNaN(umsatz[i]) || umsatz[i] === umsatz[i - 1]) continue
  if (letzter > 0 && umsatz[i] > umsatz[letzter] && close[i - 1] < close[letzter - 1]) treffer[i] = true
  letzter = i
}
signal(treffer, { title: 'Umsatz hoch, Kurs runter', color: '#FFEB3B', pos: 'below' })
alertcondition(treffer, 'Umsatz hoch, Kurs runter')

So liest du es:

• Die Linien sind Treppen: Jede Zahl steht ab ihrem Berichtstag, bis der nächste Bericht kommt. Beide teilen sich die Skala des Fensters, in Milliarden der Berichtswährung.
• 12 Monate (1) oder Quartal (0) in den Eingaben: Mit 1 vergleicht das Script den Umsatz der letzten zwölf Monate. Das glättet saisonale Quartale und reicht weiter zurück. Mit 0 vergleicht es jedes Quartal mit dem vorigen.
• Das Dreieck sitzt auf der Kerze des neuen Berichts. Verglichen wird der Schlusskurs vor diesem Bericht mit dem vor dem letzten, die Reaktion auf die Zahlen zählt also nicht mit.
• Auf Krypto, Fonds und Indizes bleibt das Fenster leer, die Konsole sagt das.
• Mit Umsatz hoch, Kurs runter im Alarm-Dialog meldet dich ein Script-Alarm beim nächsten Bericht, auf den das zutrifft. Weil das Script Unternehmenszahlen liest, prüft mantacharts diesen Alarm nur, solange das Terminal geöffnet ist.

Liquidationen als Histogramm

Die liquidierten Longs nach oben, die Shorts nach unten, in Mio. $, und ein Signal, wenn eine Kerze ungewöhnlich viele Longs liquidiert.

// CoinScript · Liquidationen
const longs = liqLong.map(v => v / 1e6)
const shorts = liqShort.map(v => -v / 1e6)
plot(longs, { title: 'Longs (Mio. $)', style: 'hist', color: '#FF1919' })
plot(shorts, { title: 'Shorts (Mio. $)', style: 'hist', colorDn: '#00FFDA' })
hline(0)
const z = zscore(liqLong, input('Fenster', 48))
const schwelle = input('Schwelle', 3)
signal(z.map(v => v > schwelle), { title: 'Long-Kaskade', color: '#FF1919', pos: 'below' })

• Nur für Krypto-Symbole mit Order Flow. Eine Kerze ohne Liquidation ist 0.
• zscore misst, wie weit die Kerze über dem Durchschnitt des Fensters liegt. Ab 3 Standardabweichungen erscheint ein Dreieck.

Relative Stärke gegen Bitcoin

Wie sich das Symbol des Charts gegenüber Bitcoin entwickelt: über 100 hat es seit dem Start des Fensters besser abgeschnitten.

// CoinScript · Relative Stärke gegen Bitcoin
const btc = symbol('BTC')
const n = input('Fenster', 90)
const rs = close.map((c, i) => (i >= n ? (c / close[i - n]) / (btc.close[i] / btc.close[i - n]) * 100 : NaN))
plot(rs, { title: 'Relative Stärke', color: '#B28CFF' })
hline(100)

• symbol('BTC') liefert die Kerzen von Bitcoin im Timeframe des Charts, nach Zeit ausgerichtet. Auf einem Aktienchart nimmt jede Kerze die letzte Bitcoin-Kerze zur selben Zeit.
• Statt 'BTC' geht jedes Symbol der Symbolsuche, etwa 'SPX' oder 'XAU'.

Bitcoin gegen die Zehnjährige

Die Rendite der zehnjährigen US-Staatsanleihe im eigenen Fenster und ein Signal, wenn sie innerhalb von 20 Kerzen um mehr als einen halben Prozentpunkt steigt.

// CoinScript · US-Rendite 10 Jahre
const r = feed('us10y')
plot(r, { title: 'US10Y %', color: '#FFEB3B' })
const punkte = input('Prozentpunkte', 0.5)
const sprung = change(r, input('Kerzen', 20)).map(v => v > punkte)
signal(sprung, { title: 'Rendite springt', color: '#FF1919', pos: 'above' })

Die Rendite ist ein Tageswert. Im 1-Stunden-Chart trägt jede Kerze eines Tages denselben Wert, change zählt dann Kerzen, nicht Tage.

RSI mit Zonen

Der RSI in einem eigenen Fenster mit Linien bei 70 und 30. Ein Signal erscheint, wenn der RSI eine Zone wieder verlässt.

// CoinScript · RSI mit Zonen
const len = input('Länge', 14)
const r = rsi(close, len)
plot(r, { title: 'RSI', color: '#FFFCF0' })
hline(70, { color: '#FF1919' })
hline(30, { color: '#00FFDA' })
const ausTief = r.map((v, i) => i > 0 && r[i - 1] < 30 && v >= 30)
const ausHoch = r.map((v, i) => i > 0 && r[i - 1] > 70 && v <= 70)
signal(ausTief, { title: 'Aus überverkauft', color: '#00FFDA', pos: 'below' })
signal(ausHoch, { title: 'Aus überkauft', color: '#FF1919', pos: 'above' })

Die Dreiecke sitzen im Preischart an den Kerzen, das Fenster zeigt den RSI.

Bollinger-Bänder mit Alarm-Bedingungen

Mittellinie und zwei Bänder im Preischart. Dazu zwei Bedingungen, auf die du einen Script-Alarm setzen kannst.

// CoinScript · Bollinger-Bänder
const len = input('Länge', 20)
const k = input('Faktor', 2)
const mid = sma(close, len)
const sd = stdev(close, len)
const upper = mid.map((m, i) => m + k * sd[i])
const lower = mid.map((m, i) => m - k * sd[i])
plot(mid, { title: 'Mitte', color: '#FFFCF0', overlay: true })
plot(upper, { title: 'Oben', color: '#FF1919', overlay: true })
plot(lower, { title: 'Unten', color: '#00FFDA', overlay: true })
alertcondition(close.map((c, i) => c > upper[i]), { title: 'Über dem oberen Band' })
alertcondition(close.map((c, i) => c < lower[i]), { title: 'Unter dem unteren Band' })

alertcondition() zeichnet nichts. Nach dem Speichern stehen „Über dem oberen Band“ und „Unter dem unteren Band“ im Alarm-Dialog unter Bedingung, wenn du Script · {Name} als Quelle wählst.

Open Interest: Veränderung in Prozent

Wie stark das Open Interest gegenüber einer festen Zahl von Kerzen zuvor gestiegen oder gefallen ist, als Histogramm.

// CoinScript · OI-Veränderung in Prozent
const n = input('Kerzen', 24)
const pct = oi.map((v, i) => (i >= n ? (v / oi[i - n] - 1) * 100 : NaN))
plot(pct, { title: 'OI Veränderung %', color: '#00FFDA', colorDn: '#FF1919', style: 'hist' })
hline(0)

• Nur für Krypto-Perpetuals. oi ist in Coin, die Prozente sind davon unabhängig.
• Steigt der Preis bei steigendem Open Interest, kommen neue Positionen dazu. Steigt er bei fallendem Open Interest, deutet das eher auf schließende Shorts hin.

Volumen-Spitzen

Zeigt das relative Volumen jeder Kerze gegenüber dem Durchschnitt davor und markiert Spitzen. Mit der Bedingung kannst du dich bei einer Spitze alarmieren lassen.

// CoinScript · Volumen-Spitzen
const len = input('Fenster', 20)
const faktor = input('Faktor', 3)
const avg = sma(volume, len)
const rv = volume.map((v, i) => v / avg[i - 1])
plot(rv, { title: 'Relatives Volumen', color: '#FFEB3B', style: 'hist' })
hline(faktor, { color: '#FF1919' })
const spitze = rv.map(v => v >= faktor)
signal(spitze, { title: 'Volumen-Spitze', color: '#FFEB3B', pos: 'above' })
alertcondition(spitze, { title: 'Volumen-Spitze' })

Das relative Volumen vergleicht jede Kerze mit dem Durchschnitt der 20 Kerzen davor. 3 heißt: dreimal so viel Volumen wie üblich. In der laufenden Kerze wächst der Wert noch, bis sie schließt. Für einen Alarm nur auf geschlossene Kerzen wähle den Auslöser Bei Kerzenschluss.

Kaufanteil der Taker

Welcher Anteil des Taker-Volumens auf Käufe entfällt, geglättet. Über 50 % dominieren aggressive Käufer.

// CoinScript · Kaufanteil der Taker
const anteil = buyVol.map((b, i) => b / (b + sellVol[i]) * 100)
plot(ema(anteil, input('Glättung', 10)), { title: 'Kaufanteil %', color: '#00FFDA' })
hline(50)

EMA-Kreuzung als Strategie

Eine einfache Trendfolge-Strategie für den Backtest: Long, wenn der schnelle EMA den langsamen nach oben kreuzt, Short beim Kreuzen nach unten.

// CoinScript · EMA-Kreuzung als Strategie
const fast = ema(close, input('Schnell', 9))
const slow = ema(close, input('Langsam', 21))
const up = fast.map((f, i) => i > 0 && fast[i - 1] <= slow[i - 1] && f > slow[i])
const down = fast.map((f, i) => i > 0 && fast[i - 1] >= slow[i - 1] && f < slow[i])
plot(fast, { title: 'EMA schnell', color: '#00FFDA', overlay: true })
plot(slow, { title: 'EMA langsam', color: '#FF1919', overlay: true })
signal(up, { title: 'Long', color: '#00FFDA', pos: 'below' })
signal(down, { title: 'Short', color: '#FF1919', pos: 'above' })

So testest du sie:

1. Wechsle in den Reiter Backtest. Er rechnet sofort, ab Werk mit Long + Short und Ausstieg Gegensignal: Jedes Gegensignal schließt die Position und eröffnet die Gegenrichtung.
2. Unter Optimierung stehen Schnell und Langsam mit einem vorgeschlagenen Bereich. Klicke auf Optimierung starten (ab Pro).
3. Mit Übernehmen schreibst du die gewählte Kombination in den Code.