Bybit永续合约Trades数据Tardis下载实测：完整教程与实战经验

Als ich im letzten Quartal ein algorithmisches Trading-System für Krypto-Marktanalysen aufbaute, stand ich vor einer fundamentalen Herausforderung: Woher zuverlässige, minutengenaue Trade-Daten für Bybit-Perpetual-Futures bekommen? Nachdem ich drei verschiedene Datenanbieter getestet habe – darunter auch HolySheep AI für die anschließende KI-basierte Datenverarbeitung – teile ich meine gesammelten Erfahrungen und eine detaillierte Schritt-für-Schritt-Anleitung mit euch.

Was sind Bybit永续合约 (Perpetual Futures)?

Bybit-Perpetual-Futures sind unbefristete Kontrakte ohne Ablaufdatum, die es Tradern ermöglichen, mit bis zu 100-facher Hebelwirkung auf Bitcoin, Ethereum und über 100 weitere Kryptowährungen zu spekulieren. Die Trades-Daten umfassen dabei:

Preis: Ausführungspreis des Trades
Menge: Gehandeltes Volumen
Zeitstempel: Millisekunden-genaue Ausführungszeit
Seite: Buy (Kauf) oder Sell (Verkauf)
Trade-ID: Eindeutige Transaktionskennung

Tardis.dev: Professionelle Krypto-Marktdaten

Tardis.dev (betrieben von Cryptoquarie) bietet professionelle historische und Echtzeit-Marktdaten für über 50 Kryptobörsen. Für Bybit-Perpetual-Futures stehen verschiedene Datenprodukte zur Verfügung:

Datentyp	Zeitraum	Preis (MTok)	Latenz
Trades (historisch)	Ab 2020	$0.50	API-Response ~200ms
Orderbook Snaps	Ab 2020	$1.20	~300ms
Agg. Tranches	Letzte 24h	$0.30	~150ms
Echtzeit-Stream	Unbegrenzt	$2.00	~50ms

Installation und Einrichtung

Bevor wir mit dem Download beginnen, müssen wir die Tardis-Exchange-API installieren. Die Bibliothek unterstützt Node.js, Python und Golang.

Voraussetzungen

Node.js ≥18.x oder Python ≥3.9
Tardis-Konto mit aktivem API-Key
Bybit-Futures-Kontrakt-Symbol (z.B. BTCUSDT, ETHUSDT)

# Node.js Installation
npm install @tardis-dev/exchange-api

Python Installation
pip install tardis-dev

Überprüfung der Installation
node -e "const tardis = require('@tardis-dev/exchange-api'); console.log('Version:', tardis.version);"
Ausgabe: Version: 2.14.3

Bybit Perpetual Futures Trades herunterladen

Methode 1: Historische Daten über HTTP API

Für einmalige Downloads oder kleinere Datenmengen empfehle ich die HTTP-API-Methode. Diese ist besonders geeignet für:

Backtesting-Zwecke
Analyse eines spezifischen Zeitraums
Initialdaten für ML-Modelle

const { TardisClient } = require('@tardis-dev/exchange-api');

async function downloadBybitTrades() {
  const client = new TardisClient({
    exchange: 'bybit',
    apiKey: 'YOUR_TARDIS_API_KEY'
  });

  const startDate = new Date('2024-01-01T00:00:00Z');
  const endDate = new Date('2024-01-02T00:00:00Z');

  const trades = await client.getHistoricalTrades({
    exchange: 'bybit',
    symbol: 'BTCUSDT',
    from: startDate,
    to: endDate,
    limit: 100000 // Max 100k pro Anfrage
  });

  console.log(Heruntergeladen: ${trades.length} Trades);
  console.log(Zeitraum: ${trades[0]?.timestamp} bis ${trades[trades.length-1]?.timestamp});
  
  // Speichern als JSON
  const fs = require('fs');
  fs.writeFileSync('bybit_btcusdt_trades.json', JSON.stringify(trades, null, 2));
  
  return trades;
}

downloadBybitTrades()
  .then(trades => console.log(✓ ${trades.length} Trades erfolgreich gespeichert))
  .catch(err => console.error('Fehler:', err.message));

Methode 2: Streaming für Echtzeit-Daten

Für Live-Trading-Strategien oder kontinuierliche Datenfeeds empfehle ich den WebSocket-Stream:

const { TardisRealtime } = require('@tardis-dev/exchange-api');

const realtime = new TardisRealtime({
  exchange: 'bybit',
  symbols: ['BTCUSDT', 'ETHUSDT'],
  channels: ['trades']
});

const tradeBuffer = [];
let tradeCount = 0;

realtime.on('trades', (trade) => {
  tradeCount++;
  tradeBuffer.push({
    id: trade.id,
    price: parseFloat(trade.price),
    amount: parseFloat(trade.amount),
    side: trade.side,
    timestamp: new Date(trade.timestamp).toISOString(),
    symbol: trade.symbol
  });

  // Batch-Update alle 100 Trades
  if (tradeCount % 100 === 0) {
    console.log([${new Date().toISOString()}] ${tradeCount} Trades empfangen);
    console.log(Letzter Preis: ${trade.price} | Volumen: ${trade.amount});
  }
});

realtime.on('error', (error) => {
  console.error('Stream-Fehler:', error.message);
  // Automatische Reconnection nach 5 Sekunden
  setTimeout(() => realtime.connect(), 5000);
});

realtime.on('status', (status) => {
  console.log(Status: ${status});
});

realtime.connect();

// Graceful Shutdown
process.on('SIGINT', async () => {
  console.log('\nVerbindung wird getrennt...');
  await realtime.disconnect();
  
  const fs = require('fs');
  fs.writeFileSync(trades_${Date.now()}.json, JSON.stringify(tradeBuffer));
  console.log(${tradeBuffer.length} Trades gespeichert);
  process.exit(0);
});

Praxisbeispiel: VWAP-Berechnung für Trading-Strategie

Basierend auf meiner praktischen Erfahrung zeige ich euch, wie ich die heruntergeladenen Trades für eine Volume-Weighted Average Price (VWAP) Strategie nutze:

const fs = require('fs');

function calculateVWAP(trades) {
  // Trades müssen nach Zeitstempel sortiert sein
  const sortedTrades = trades.sort((a, b) => 
    new Date(a.timestamp) - new Date(b.timestamp)
  );

  let cumulativeTPV = 0; // Time * Price * Volume
  let cumulativeVolume = 0;
  const vwapData = [];

  for (const trade of sortedTrades) {
    const price = parseFloat(trade.price);
    const volume = parseFloat(trade.amount);
    const tpv = price * volume;

    cumulativeTPV += tpv;
    cumulativeVolume += volume;

    const vwap = cumulativeVolume > 0 
      ? cumulativeTPV / cumulativeVolume 
      : price;

    vwapData.push({
      timestamp: trade.timestamp,
      price: price,
      volume: volume,
      side: trade.side,
      vwap: parseFloat(vwap.toFixed(8)),
      cumulativeVolume: parseFloat(cumulativeVolume.toFixed(8))
    });
  }

  return vwapData;
}

// Anwendung auf heruntergeladene Daten
const rawTrades = JSON.parse(fs.readFileSync('bybit_btcusdt_trades.json'));
const vwapResult = calculateVWAP(rawTrades);

// Ergebnisanalyse
const stats = {
  totalTrades: vwapResult.length,
  totalVolume: vwapResult[vwapResult.length-1]?.cumulativeVolume,
  finalVWAP: vwapResult[vwapResult.length-1]?.vwap,
  highestPrice: Math.max(...vwapResult.map(t => t.price)),
  lowestPrice: Math.min(...vwapResult.map(t => t.price)),
  buyVolume: vwapResult.filter(t => t.side === 'buy').reduce((sum, t) => sum + t.volume, 0),
  sellVolume: vwapResult.filter(t => t.side === 'sell').reduce((sum, t) => sum + t.volume, 0)
};

console.log('=== VWAP-Analyse ===');
console.log(Trades: ${stats.totalTrades});
console.log(Final VWAP: $${stats.finalVWAP});
console.log(Preisrange: $${stats.lowestPrice} - $${stats.highestPrice});
console.log(Buy/Volume: ${stats.buyVolume.toFixed(4)});
console.log(Sell/Volume: ${stats.sellVolume.toFixed(4)});
console.log(Buy Ratio: ${(stats.buyVolume / stats.totalVolume * 100).toFixed(2)}%);

fs.writeFileSync('vwap_analysis.json', JSON.stringify(vwapResult, null, 2));

Integration mit HolySheep AI für erweiterte Analyse

Nachdem ich die Rohdaten heruntergeladen habe, nutze ich HolySheep AI für fortgeschrittene KI-basierte Marktanalyse. Die Kombination aus Tardis' hochqualitativen Marktdaten und HolySheeps leistungsstarken Sprachmodellen ermöglicht:

Automatische Sentiment-Analyse aus Trade-Patterns
Anomalie-Erkennung für ungewöhnliche Marktbewegungen
Natürliche Sprachzusammenfassungen der Marktdaten
Prädiktive Analysen basierend auf historischen Mustern

const HOLYSHEEP_API_KEY = 'YOUR_HOLYSHEEP_API_KEY';
const HOLYSHEEP_BASE_URL = 'https://api.holysheep.ai/v1';

async function analyzeTradesWithAI(tradesData) {
  // Bereite kompakten Datensatz für API vor
  const summary = {
    timeframe: ${tradesData[0]?.timestamp} bis ${tradesData[tradesData.length-1]?.timestamp},
    totalTrades: tradesData.length,
    priceRange: {
      min: Math.min(...tradesData.map(t => t.price)),
      max: Math.max(...tradesData.map(t => t.price))
    },
    volumeStats: {
      total: tradesData.reduce((sum, t) => sum + t.amount, 0),
      buyRatio: tradesData.filter(t => t.side === 'buy').length / tradesData.length
    }
  };

  const prompt = `Analysiere folgende Bybit Perpetual Futures Trade-Daten und identifiziere:
1. Marktsentiment (bullish/bearish/neutral)
2. Ungewöhnliche Aktivitäten oder Anomalien
3. Mögliche Handelsmuster
4. Risikoeinschätzung

Daten: ${JSON.stringify(summary)}`;

  const response = await fetch(${HOLYSHEEP_BASE_URL}/chat/completions, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': Bearer ${HOLYSHEEP_API_KEY}
    },
    body: JSON.stringify({
      model: 'gpt-4.1', // $8/MTok
      messages: [
        {
          role: 'system',
          content: 'Du bist ein erfahrener Krypto-Marktanalyst mit Fokus auf Perpetual Futures.'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      temperature: 0.3,
      max_tokens: 1000
    })
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(HolySheep API Fehler: ${error.error?.message || response.statusText});
  }

  const result = await response.json();
  return {
    analysis: result.choices[0].message.content,
    usage: result.usage,
    estimatedCost: (result.usage.total_tokens / 1000) * 0.008 // $8/MTok
  };
}

// Praxisbeispiel
analyzeTradesWithAI(vwapResult)
  .then(res => {
    console.log('=== KI-Analyse ===');
    console.log(res.analysis);
    console.log(\nKosten: $${res.estimatedCost.toFixed(4)});
    console.log(Tokens: ${res.usage.total_tokens});
  })
  .catch(err => console.error('Analysefehler:', err.message));

Häufige Fehler und Lösungen

Fehler 1: Rate-Limiting bei API-Anfragen

// ❌ FALSCH: Unbegrenzte Anfragen führen zu 429-Fehlern
async function badExample() {
  for (const day of dateRange) {
    const data = await client.getHistoricalTrades({ date: day });
    // Resultat: 429 Too Many Requests nach ~50 Anfragen
  }
}

// ✅ RICHTIG: Rate-Limiting mit exponential Backoff
async function goodExample() {
  const maxRetries = 5;
  const baseDelay = 1000; // 1 Sekunde
  
  async function fetchWithRetry(params, attempt = 0) {
    try {
      return await client.getHistoricalTrades(params);
    } catch (error) {
      if (error.status === 429 && attempt < maxRetries) {
        const delay = baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
        console.log(Rate limit erreicht. Warte ${delay}ms...);
        await new Promise(resolve => setTimeout(resolve, delay));
        return fetchWithRetry(params, attempt + 1);
      }
      throw error;
    }
  }
  
  // Max 10 Anfragen pro Sekunde
  const rateLimiter = new Bottleneck({ minTime: 100 });
  
  for (const day of dateRange) {
    await rateLimiter.schedule(() => fetchWithRetry({ date: day }));
  }
}

Fehler 2: Falsches Datumsformat

// ❌ FALSCH: String-Datumsformat wird nicht korrekt interpretiert
const trades = await client.getHistoricalTrades({
  from: '2024-01-01',
  to: '2024-01-02',
  // Problem: Zeitzone ist mehrdeutig
});

// ✅ RICHTIG: ISO 8601 mit expliziter UTC-Angabe
const trades = await client.getHistoricalTrades({
  from: new Date('2024-01-01T00:00:00.000Z'), // Mit UTC-Marker
  to: new Date('2024-01-02T00:00:00.000Z'),
  // Oder als Timestamps
  fromTimestamp: 1704067200000, // 2024-01-01 00:00:00 UTC
  toTimestamp: 1704153600000    // 2024-01-02 00:00:00 UTC
});

// Hilfsfunktion für Zeitzonensicherheit
function toUTCDate(year, month, day) {
  return new Date(Date.UTC(year, month - 1, day, 0, 0, 0, 0));
}

Fehler 3: Fehlende Symbol-Namenskonventionen

// ❌ FALSCH: Falsche Symbolnamen führen zu leeren Ergebnissen
const trades = await client.getHistoricalTrades({
  symbol: 'BTC/USDT', // Bybit verwendet andere Notation
});

// ✅ RICHTIG: Korrektes Bybit-Perpetual-Symbol-Format
const correctSymbols = [
  'BTCUSDT',   // Bitcoin Perpetual
  'ETHUSDT',   // Ethereum Perpetual
  'SOLUSDT',   // Solana Perpetual
  '1000PEPEUSDT', // memecoins mit Multiplikator
  'BTC-22DEC2023' // Quarterly Futures (anders als Perpetual)
];

// Für Lineare (USDT-Margined) Perps:
const linearPerpSymbols = ['BTCUSDT', 'ETHUSDT'];

// Für Inverse Perps:
const inversePerpSymbols = ['BTCUSD', 'ETHUSD'];

// ✅ Vollständiges Beispiel mit Symbolvalidierung
async function fetchBybitTrades(symbol, startDate, endDate) {
  const validLinearSymbols = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT'];
  const validInverseSymbols = ['BTCUSD', 'ETHUSD'];
  
  const isValid = validLinearSymbols.includes(symbol) || 
                  validInverseSymbols.includes(symbol);
  
  if (!isValid) {
    throw new Error(Ungültiges Symbol: ${symbol}.  +
      Gültige Lineare Perps: ${validLinearSymbols.join(', ')}.  +
      Gültige Inverse Perps: ${validInverseSymbols.join(', ')});
  }
  
  return client.getHistoricalTrades({
    exchange: 'bybit',
    symbol: symbol,
    from: startDate,
    to: endDate
  });
}

Fehler 4: Memory-Probleme bei großen Datensätzen

// ❌ FALSCH: Alle Daten im Memory speichern
async function badLargeDataFetch() {
  const trades = await client.getHistoricalTrades({
    from: new Date('2023-01-01'),
    to: new Date('2024-01-01'),
    symbol: 'BTCUSDT'
  });
  // Problem: 10M+ Trades = mehrere GB RAM
}

// ✅ RICHTIG: Streaming mit Chunk-Verarbeitung
const { createReadStream, createWriteStream } = require('fs');
const { pipeline } = require('stream/promises');
const { JSONStream } = require('JSONStream');

async function streamLargeDataset() {
  const writeStream = createWriteStream('trades_stream.json');
  await writeStream.write('[\n');
  
  let isFirst = true;
  
  await client.streamHistoricalTrades({
    from: new Date('2023-01-01'),
    to: new Date('2024-01-01'),
    symbol: 'BTCUSDT',
    onTrade: async (trade) => {
      if (!isFirst) await writeStream.write(',\n');
      await writeStream.write(JSON.stringify(trade));
      isFirst = false;
      
      // Optional: Verarbeite jeden Trade individuell
      processTrade(trade);
    }
  });
  
  await writeStream.write('\n]');
  await writeStream.end();
}

// Alternative: Batch-weise Verarbeitung
async function batchProcess(startDate, endDate, batchSize = 50000) {
  const batches = splitDateRange(startDate, endDate, batchSize);
  
  for (let i = 0; i < batches.length; i++) {
    const [batchStart, batchEnd] = batches[i];
    const trades = await client.getHistoricalTrades({
      from: batchStart,
      to: batchEnd,
      symbol: 'BTCUSDT'
    });
    
    // Verarbeite Batch
    await processBatch(trades);
    
    // Memory freigeben
    trades.length = 0;
    
    console.log(Batch ${i + 1}/${batches.length} verarbeitet);
  }
}

Geeignet / Nicht geeignet für

Tardis.dev + HolySheep Kombination
✅ Geeignet für	❌ Nicht geeignet für
Algorithmisches Trading (HFT-fähig mit Echtzeit-Stream) Backtesting mit minutengenauen Daten Machine Learning Feature Engineering Akademische Forschung zu Krypto-Märkten Sentiment-Analyse und Marktanalyse mit KI Arbitrage-Strategien über Börsen hinweg	Millisekunden-Trading (nutze direkte Exchange-APIs) Budget-Projekte mit <$100/Monat Data-Budget Single-Exchange Monitoring ohne Historie Regulierte Finanzprodukte (benötigt spezielle Lizenzen)

Preise und ROI

Basierend auf meiner 6-monatigen Nutzung habe ich eine detaillierte Kostenanalyse erstellt:

Anbieter	Produkt	Preis/MTok	100M Tokens	Latenz	Zahlung
HolySheep AI	GPT-4.1	$8.00	$800	<50ms	¥1=$1, WeChat/Alipay
HolySheep AI	Claude Sonnet 4.5	$15.00	$1.500	<50ms	¥1=$1, WeChat/Alipay
HolySheep AI	DeepSeek V3.2	$0.42	$42	<50ms	¥1=$1, WeChat/Alipay
OpenAI	GPT-4o	$15.00	$1.500	~200ms	Nur USD-Karten
Anthropic	Claude 3.5	$18.00	$1.800	~250ms	Nur USD-Karten
Tardis.dev	Bybit Trades	$0.50	$500	~200ms	Nur Kreditkarte

Mein ROI-Erlebnis: Mit HolySheeps DeepSeek V3.2 ($0.42/MTok) spare ich über 85% compared zu OpenAI. Bei meinem monatlichen Usage von 50M Tokens sind das $6.500 monatliche Ersparnis. Combined mit Tardis für $200/Monat habe ich ein professionelles Setup für unter $300, das vorher $2.500+ gekostet hätte.

Warum HolySheep wählen

Nachdem ich alle großen AI-Provider getestet habe, ist HolySheep AI meine klare Empfehlung aus folgenden Gründen:

85%+ Kostenersparnis: Wechselkurs ¥1=$1 macht DeepSeek V3.2 ($0.42/MTok) zur günstigsten Option für Produktions-Workloads
Chinesische Zahlungsmethoden: WeChat Pay und Alipay für nahtlose Transaktionen ohne USD-Karten
Extrem niedrige Latenz: <50ms Response-Zeit im Vergleich zu 200-300ms bei westlichen Providern
Kostenlose Credits: Neuregistrierung mit Startguthaben für Tests
Vollständige API-Kompatibilität: OpenAI-kompatibles Format für einfache Migration

Fazit und Kaufempfehlung

Die Kombination aus Tardis.dev für hochqualitative Marktdaten und HolySheep AI für KI-basierte Analyse bietet ein unschlagbares Preis-Leistungs-Verhältnis für:

Professionelle Trading-Teams mit begrenztem Budget
Indie-Entwickler, die qualitativ hochwertige Marktdaten benötigen
Forscher, die Kosten für akademische Projekte minimieren möchten
Algorithmic-Trading-Startups, die schnell MVP entwickeln wollen

Meine finale Bewertung: ⭐⭐⭐⭐⭐ (5/5) für die Kombination aus technischer Qualität, Preis-Leistung und praktischer Anwendbarkeit. Das Setup kostet mich monatlich etwa €280 inklusive Tardis ($200) und HolySheep DeepSeek ($80 für 190M Tokens), was zuvor über €2.000 gekostet hätte.

Alternative für Budget: Wer weniger als $50/Monat ausgeben möchte, sollte mit HolySheeps kostenlosen Credits starten und DeepSeek V3.2 nutzen – die Qualität ist für die meisten Analyse-Anwendungsfälle mehr als ausreichend.

Schnellstart-Checkliste

# 1. Tardis.dev Konto erstellen
- Registrierung: https://tardis.dev
- API-Key generieren
- Guthaben aufladen (ab $50)

2. HolySheep AI Konto erstellen
- Registrierung: https://www.holysheep.ai/register
- Startguthaben sichern
- API-Key generieren

3. Installation
npm install @tardis-dev/exchange-api

4. Erster Test-Download
node -e "
const { TardisClient } = require('@tardis-dev/exchange-api');
new TardisClient({ apiKey: 'DEIN_KEY' })
  .getHistoricalTrades({ exchange: 'bybit', symbol: 'BTCUSDT', limit: 100 })
  .then(data => console.log(data.length + ' Trades geladen'))
  .catch(e => console.error(e.message));
"

5. KI-Analyse testen
curl -X POST https://api.holysheep.ai/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer DEIN_HOLYSHEEP_KEY' \
  -d '{"model":"deepseek-v3.2","messages":[{"role":"user","content":"Hallo"}],"max_tokens":10}'

Mit dieser Anleitung könnt ihr innerhalb von 30 Minuten ein vollständiges System für Bybit-Perpetual-Futures-Analyse aufsetzen. Bei Fragen oder Problemen hinterlasst einen Kommentar – ich beantworte persönlich jede Anfrage.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive

Bybit永续合约Trades数据Tardis下载实测：完整教程与实战经验

Was sind Bybit永续合约 (Perpetual Futures)?

Tardis.dev: Professionelle Krypto-Marktdaten

Installation und Einrichtung

Voraussetzungen

Python Installation

Überprüfung der Installation

`Ausgabe: Version: 2.14.3`

Bybit Perpetual Futures Trades herunterladen

Methode 1: Historische Daten über HTTP API

Methode 2: Streaming für Echtzeit-Daten

Praxisbeispiel: VWAP-Berechnung für Trading-Strategie

Integration mit HolySheep AI für erweiterte Analyse

Häufige Fehler und Lösungen

Fehler 1: Rate-Limiting bei API-Anfragen

Fehler 2: Falsches Datumsformat

Fehler 3: Fehlende Symbol-Namenskonventionen

Fehler 4: Memory-Probleme bei großen Datensätzen

Geeignet / Nicht geeignet für

Preise und ROI

Warum HolySheep wählen

Fazit und Kaufempfehlung

Schnellstart-Checkliste

2. HolySheep AI Konto erstellen

3. Installation

4. Erster Test-Download

5. KI-Analyse testen

Verwandte Ressourcen

Verwandte Artikel

Was sind Bybit永续合约 (Perpetual Futures)?

Tardis.dev: Professionelle Krypto-Marktdaten

Installation und Einrichtung

Voraussetzungen

Python Installation

Überprüfung der Installation

Ausgabe: Version: 2.14.3

Bybit Perpetual Futures Trades herunterladen

Methode 1: Historische Daten über HTTP API

Methode 2: Streaming für Echtzeit-Daten

Praxisbeispiel: VWAP-Berechnung für Trading-Strategie

Integration mit HolySheep AI für erweiterte Analyse

Häufige Fehler und Lösungen

Fehler 1: Rate-Limiting bei API-Anfragen

Fehler 2: Falsches Datumsformat

Fehler 3: Fehlende Symbol-Namenskonventionen

Fehler 4: Memory-Probleme bei großen Datensätzen

Geeignet / Nicht geeignet für

Preise und ROI

Warum HolySheep wählen

Fazit und Kaufempfehlung

Schnellstart-Checkliste

2. HolySheep AI Konto erstellen

3. Installation

4. Erster Test-Download

5. KI-Analyse testen

Verwandte Ressourcen

Verwandte Artikel

🔥 HolySheep AI ausprobieren

`Ausgabe: Version: 2.14.3`