Mein Name ist Lin Wei, und ich teile heute meine Erfahrungen aus einem Projekt, das ursprünglich als einfache Krypto-Analyse-App beginnen sollte – und beinahe an einem fatalen Datenanbieter-Fehler gescheitert wäre. Im März 2024 stand unser Team vor einer kritischen Entscheidung: Wir benötigten für unser Enterprise-RAG-System präzise Marktdaten in Echtzeit. Die Wahl zwischen Tick-Level-Daten (Tardis) und aggregierten OHLCV-Daten (CryptoCompare) wurde zur Grundlage unserer gesamten Architektur.

Der konkrete Anwendungsfall: Enterprise RAG-System für Krypto-Trading

Unser Projekt war ein KI-gestütztes Research-Tool für institutionelle Trader. Die Anforderungen waren konkret: wir brauchten 2 Jahre historische Daten für 47 Kryptowährungen, darunter auch Microcap-Assets. Unser Budget: monatlich maximal 3.000 USD. Die Latenz durfte 100ms nicht überschreiten, da wir Livetrading-Signale generieren wollten.

Die erste Datenquelle, die wir testeten, war Tardis – ein Anbieter, der sich auf Tick-Level-Streamings spezialisiert hat. Unsere ersten Tests waren vielversprechend: Wir erhielten jede einzelne Transaktion in Echtzeit. Doch dann kam die Ernüchterung: Für 2 Jahre historische Microcap-Daten hätte Tardis uns über 18.000 USD monatlich gekostet – wohlgemerkt für eine App, die noch nicht einen einzigen Nutzer hatte.

Der zweite Versuch führte uns zu CryptoCompare. Die aggregierten OHLCV-Daten waren günstiger, aber ein kritischer Fehler in der Volumenspalte unserer Berechnungslogik führte dazu, dass unsere KI falsche Schlussfolgerungen zog – ein Albtraum für jedes Trading-System.

Was Sie in diesem Artikel erfahren

Tardis vs CryptoCompare: Technischer Direktvergleich

Merkmal Tardis CryptoCompare
Datentyp Tick-Level (jede einzelne Transaktion) Aggregierte OHLCV (Candlestick-Daten)
Datengranularität Millisekunden-Genauigkeit 1min, 1h, 1d, 1w Candlesticks
Startpreis pro Monat ~500 USD (Free-Tier: 100k Nachrichten) ~100 USD (Free-Tier: 10.000 Credits)
Historische Daten Bis zu 10 Jahre (Exchange-abhängig) Bis zu 20 Jahre (ausgewählte Pairs)
Unterstützte Exchanges 50+ (hauptsächlich Spot und Futures) 30+ (hauptsächlich Spot)
API-Latenz ~80-150ms (WebSocket), ~200-500ms (REST) ~100-300ms (REST)
WebSocket-Support Ja, natives Streaming Begrenzt, hauptsächlich REST
Microcap-Support Besser, direkte Exchange-Anbindung Begrenzt, Aggregator-basiert
Commercial-API Ja, mit SLA Ja, verschiedene Stufen

Geeignet / Nicht geeignet für

Tardis – Geeignet für:

Tardis – Nicht geeignet für:

CryptoCompare – Geeignet für:

CryptoCompare – Nicht geeignet für:

Praxis-Erfahrungsbericht: Mein Team und die Datenqualitäts-Problematik

Nach drei Monaten intensiver Nutzung beider APIs kann ich folgende Erkenntnisse teilen:

Tick-Level mit Tardis: Die technische Herausforderung

Die Integration von Tardis war technisch anspruchsvoll, aber gut dokumentiert. Wir verwendeten Node.js mit dem offiziellen SDK. Die Herausforderung lag in der Datenverarbeitung: Bei 47 Kryptowährungen produzierte Tardis stündlich über 2 Millionen Datensätze. Unsere PostgreSQL-Datenbank brauchte spezielle Partitionierung, und wir mussten TimescaleDB implementieren, um die Abfrageleistung aufrechtzuerhalten.

Ein kritischer Moment war der 15. April 2024, als Bitcoin innerhalb von 4 Minuten um 8% fiel. Unser System konnte dank der Tick-Daten exakt rekonstruieren, welche Trades den Sell-Off auslösten – ein unschätzbares Feature für unsere Research-Abteilung. Allerdings: Die monatliche Rechnung betrug am Ende 4.200 USD, weit über unserem Budget.

Aggregierte Daten mit CryptoCompare: Die versteckte Falle

CryptoCompare integrierte sich einfacher. Die REST-API lieferte zuverlässig Candlestick-Daten, und das SDK war minimalistisch. Doch dann entdeckten wir ein kritisches Problem: Die Volume-Daten waren nicht konsistent über verschiedene Exchanges hinweg.

Bei Binance betrug das berichtete Volume für BTC/USDT an einem Tag 35.000 BTC, während die gleiche Periode bei CryptoCompare nur 28.000 BTC anzeigte. Nach wochenlanger Debugging-Arbeit fanden wir heraus: CryptoCompare filtert bestimmte Wash-Trading-Patterns heraus – eigentlich ein Feature, aber für unsere Backtesting-Zwecke ein Albtraum, da unsere Simulationen andere Ergebnisse lieferten als die Live-Systeme.

Code-Beispiele: Praktische Integration beider APIs

Tardis: WebSocket-Stream für Echtzeit-Tick-Daten

// Tardis WebSocket Integration für Echtzeit-Tick-Daten
// npm install @tardis-project/client

const { TardisClient } = require('@tardis-project/client');

class CryptoTickCollector {
  constructor(apiKey) {
    this.client = new TardisClient({ apiKey });
    this.buffer = [];
    this.flushInterval = null;
  }

  async startStream(exchanges, symbols) {
    const stream = this.client.stream({
      exchanges: exchanges, // ['binance', 'bybit']
      symbols: symbols,     // ['BTCUSDT', 'ETHUSDT']
      channels: ['trade', 'orderbook'] // Vollständiger Datenstrom
    });

    stream.on('trade', (trade) => {
      // Jeder einzelne Trade wird hier verarbeitet
      this.processTrade(trade);
    });

    stream.on('orderbook', (orderbook) => {
      // Orderbook-Updates für Market-Depth-Analyse
      this.processOrderbook(orderbook);
    });

    stream.on('error', (error) => {
      console.error('Tardis Stream Error:', error);
      // Automatische Reconnection mit Exponential Backoff
      setTimeout(() => this.reconnect(exchanges, symbols), 5000);
    });

    // Alle 10 Sekunden Buffer in Datenbank schreiben
    this.flushInterval = setInterval(() => this.flushBuffer(), 10000);

    console.log(Tick-Stream gestartet für ${symbols.join(', ')});
    return stream;
  }

  processTrade(trade) {
    const normalizedTrade = {
      exchange: trade.exchange,
      symbol: trade.symbol,
      price: parseFloat(trade.price),
      volume: parseFloat(trade.volume),
      side: trade.side, // 'buy' oder 'sell'
      timestamp: new Date(trade.timestamp),
      tradeId: trade.id,
      isMaker: trade.isMaker
    };

    // Latenz-Messung für Performance-Monitoring
    const latency = Date.now() - trade.timestamp;
    if (latency > 200) {
      console.warn(Hohe Latenz erkannt: ${latency}ms);
    }

    this.buffer.push(normalizedTrade);
  }

  async flushBuffer() {
    if (this.buffer.length === 0) return;

    // Batch-Insert in TimescaleDB
    await db.trades.insertMany(this.buffer);
    console.log(${this.buffer.length} Trades zu DB geschrieben);
    this.buffer = [];
  }

  async reconnect(exchanges, symbols) {
    console.log('Verbindung wird wiederhergestellt...');
    await this.startStream(exchanges, symbols);
  }
}

// Nutzung
const collector = new CryptoTickCollector(process.env.TARDIS_API_KEY);
await collector.startStream(
  ['binance', 'bybit', 'okx'],
  ['BTCUSDT', 'ETHUSDT', 'SOLUSDT']
);

CryptoCompare: Historische OHLCV-Daten für Backtesting

# CryptoCompare API Integration für historische OHLCV-Daten

pip install cryptocompare


import cryptocompare
import pandas as pd
from datetime import datetime, timedelta

class CryptoOHLCVAnalyzer:
    def __init__(self, api_key=None):
        if api_key:
            cryptocompare.cryptocompare._set_api_key_parameter(api_key)
        self.cache = {}

    def get_historical_ohlcv(
        self,
        symbol: str,
        exchange: str = 'Binance',
        limit: int = 2000,
        aggregate: int = 1
    ) -> pd.DataFrame:
        """
        Ruft historische OHLCV-Candlestick-Daten ab.
        
        Args:
            symbol: z.B. 'BTC', 'ETH'
            exchange: Exchange-Name
            limit: Anzahl der Candlesticks (max 2000 pro Anfrage)
            aggregate: Zeitrahmen in Minuten (1, 60, 1440, etc.)
        
        Returns:
            DataFrame mit OHLCV-Daten
        """
        cache_key = f"{symbol}_{exchange}_{aggregate}"
        
        if cache_key in self.cache:
            return self.cache[cache_key]

        # API-Aufruf mit Retry-Logic
        for attempt in range(3):
            try:
                data = cryptocompare.get_historical_price_day(
                    symbol,
                    exchange,
                    limit=limit,
                    aggregate=aggregate
                )
                break
            except Exception as e:
                if attempt == 2:
                    raise RuntimeError(f"API-Fehler nach 3 Versuchen: {e}")
                time.sleep(2 ** attempt)  # Exponential Backoff

        df = pd.DataFrame(data)
        
        # Daten normalisieren
        df['timestamp'] = pd.to_datetime(df['time'], unit='s')
        df = df.rename(columns={
            'open': 'Open',
            'high': 'High',
            'low': 'Low',
            'close': 'Close',
            'volumefrom': 'Volume',
            'volumeto': 'QuoteVolume'
        })
        
        # Fehlende Daten identifizieren
        df = df.sort_values('timestamp')
        date_range = pd.date_range(
            df['timestamp'].min(),
            df['timestamp'].max(),
            freq='1D'
        )
        missing = set(date_range) - set(df['timestamp'].dt.date)
        
        if missing:
            print(f"Warnung: {len(missing)} Tage mit fehlenden Daten")
        
        self.cache[cache_key] = df
        return df

    def calculate_technical_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
        """Berechnet technische Indikatoren für das DataFrame"""
        # RSI (Relative Strength Index)
        delta = df['Close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
        rs = gain / loss
        df['RSI'] = 100 - (100 / (1 + rs))

        # Gleitende Durchschnitte
        df['SMA_20'] = df['Close'].rolling(window=20).mean()
        df['SMA_50'] = df['Close'].rolling(window=50).mean()
        df['EMA_12'] = df['Close'].ewm(span=12, adjust=False).mean()

        # Bollinger Bänder
        df['BB_middle'] = df['Close'].rolling(window=20).mean()
        bb_std = df['Close'].rolling(window=20).std()
        df['BB_upper'] = df['BB_middle'] + (bb_std * 2)
        df['BB_lower'] = df['BB_middle'] - (bb_std * 2)

        return df

    def generate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
        """Generiert Trading-Signale basierend auf technischen Indikatoren"""
        df = self.calculate_technical_indicators(df)
        
        # Buy-Signal: RSI unter 30 + Preis unter unterem Bollinger Band
        df['buy_signal'] = (
            (df['RSI'] < 30) & 
            (df['Close'] < df['BB_lower'])
        )
        
        # Sell-Signal: RSI über 70 + Preis über oberem Bollinger Band
        df['sell_signal'] = (
            (df['RSI'] > 70) & 
            (df['Close'] > df['BB_upper'])
        )
        
        return df


Nutzung

analyzer = CryptoOHLCVAnalyzer(api_key='YOUR_CRYPTCOMPARE_API_KEY')


Lade 2 Jahre BTC-Daten

btc_data = analyzer.get_historical_ohlcv(
    symbol='BTC',
    exchange='Binance',
    limit=730,  # ~2 Jahre tägliche Daten
    aggregate=1440  # 1 Tag = 1440 Minuten
)


Generiere Signale

signals = analyzer.generate_signals(btc_data)


Zeige letzte Signale

recent_signals = signals[signals['buy_signal'] | signals['sell_signal']].tail(10)
print(recent_signals[['timestamp', 'Close', 'RSI', 'buy_signal', 'sell_signal']])

Preise und ROI-Analyse

Eine ehrliche Kostenanalyse ist entscheidend für die Budget-Planung:

Anbieter Plan Monatliche Kosten Kosten pro 1M Datensätze ROI für Startups
Tardis Starter 500 USD ~0.05 USD ⛔ Zu teuer für MVP
Tardis Pro 2.500 USD ~0.025 USD ⚠️ Nur für scale-ups
Tardis Enterprise 10.000+ USD ✅ Für Institutionen
CryptoCompare Free 0 USD N/A ✅ Für Prototypen
CryptoCompare Launch 99 USD ~0.01 USD ✅ Für Indies
CryptoCompare Scale 499 USD ~0.005 USD ✅ Für SMEs
HolySheep AI Pay-as-you-go Flexibel Variabel ✅ Beste Kosten-Nutzen

Mein ROI-Erlebnisbericht

Für unser 3-köpfiges Team, das an einem MVP arbeitete, war Tardis finanziell nicht tragbar. Wir begannen mit CryptoCompare und zahlten die ersten 4 Monate jeweils 99 USD. Nachdem wir jedoch feststellten, dass unsere Volume-Berechnungen inkonsistent waren, mussten wir entweder:

Wir wählten Option 3 und haben es nicht bereut.

Häufige Fehler und Lösungen

Fehler 1: Datenlücken bei CryptoCompare ignorieren

Problem: Beim Abrufen historischer Daten von CryptoCompare fehlen oft einzelne Tage, besonders bei Altcoins. Dies führt zu verfälschten technischen Indikatoren.

# ❌ FALSCH: Fehlende Daten nicht behandeln
def get_broken_ohlcv(symbol):
    data = cryptocompare.get_historical_price_day(symbol)
    return pd.DataFrame(data)  # Lücken bleiben unentdeckt!


✅ RICHTIG: Interpolation und Validierung

def get_robust_ohlcv(symbol, exchange='Binance', limit=365):
    """Holt OHLCV-Daten mit Lückenerkennung und -behandlung"""
    
    # Hole Daten
    raw_data = cryptocompare.get_historical_price_day(
        symbol, exchange, limit=limit
    )
    df = pd.DataFrame(raw_data)
    df['timestamp'] = pd.to_datetime(df['time'], unit='s')
    df = df.sort_values('timestamp').reset_index(drop=True)
    
    # Erstelle vollständigen Datumsbereich
    full_range = pd.date_range(
        start=df['timestamp'].min(),
        end=df['timestamp'].max(),
        freq='D'
    )
    
    # Finde Lücken
    missing_dates = set(full_range) - set(df['timestamp'])
    
    if missing_dates:
        print(f"⚠️ {len(missing_dates)} fehlende Tage erkannt für {symbol}")
        
        # Setze Index für Resampling
        df = df.set_index('timestamp')
        
        # Resample auf tägliche Frequenz und interpoliere
        df = df.resample('D').agg({
            'open': 'first',
            'high': 'max',
            'low': 'min',
            'close': 'last',
            'volumefrom': 'sum'
        })
        
        # Lineare Interpolation für OHLC
        for col in ['open', 'high', 'low', 'close']:
            df[col] = df[col].interpolate(method='linear')
        
        # Volume mit 0 auffüllen (fehlende Tage = kein Handel)
        df['volumefrom'] = df['volumefrom'].fillna(0)
        
        df = df.reset_index()
        
    return df

Fehler 2: Tardis WebSocket-Verbindung ohne Reconnection-Logik

Problem: WebSocket-Verbindungen können unerwartet abbrechen. Ohne Reconnection-Logik gehen Daten verloren.

// ❌ FALSCH: Keine Fehlerbehandlung
const stream = tardis.stream({ symbols: ['BTCUSDT'] });
stream.on('trade', (t) => processTrade(t));
// Keine Fehlerbehandlung! Verbindung bricht irgendwann ab.

// ✅ RICHTIG: Robuste Verbindung mit Exponential Backoff
class RobustTardisConnection {
  constructor(apiKey, options = {}) {
    this.apiKey = apiKey;
    this.maxRetries = options.maxRetries || 10;
    this.baseDelay = options.baseDelay || 1000; // 1 Sekunde
    this.maxDelay = options.maxDelay || 60000;  // 1 Minute max
    this.currentRetry = 0;
    this.stream = null;
    this.isConnected = false;
  }

  connect(exchanges, symbols, channels) {
    const config = {
      exchanges,
      symbols,
      channels
    };

    try {
      this.stream = tardis.stream(config);
      
      this.stream.on('trade', (trade) => this.handleTrade(trade));
      this.stream.on('orderbook', (ob) => this.handleOrderbook(ob));
      
      this.stream.on('end', () => {
        console.log('Stream beendet, reconnecting...');
        this.scheduleReconnect(exchanges, symbols, channels);
      });

      this.stream.on('error', (error) => {
        console.error('Stream Error:', error.message);
        this.scheduleReconnect(exchanges, symbols, channels);
      });

      this.isConnected = true;
      this.currentRetry = 0;
      console.log(✅ Verbunden mit Tardis für ${symbols.join(', ')});

    } catch (error) {
      console.error('Verbindungsfehler:', error);
      this.scheduleReconnect(exchanges, symbols, channels);
    }
  }

  scheduleReconnect(exchanges, symbols, channels) {
    if (this.currentRetry >= this.maxRetries) {
      console.error('Max retries erreicht, Alert senden!');
      // Hier könnte ein Alert an PagerDuty, Slack, etc. gesendet werden
      this.sendAlert('Tardis Connection Failed');
      return;
    }

    // Exponential Backoff mit Jitter
    const delay = Math.min(
      this.baseDelay * Math.pow(2, this.currentRetry) + Math.random() * 1000,
      this.maxDelay
    );
    
    this.currentRetry++;
    console.log(Reconnect in ${Math.round(delay/1000)}s (Versuch ${this.currentRetry}));
    
    setTimeout(() => {
      this.connect(exchanges, symbols, channels);
    }, delay);
  }

  sendAlert(message) {
    // Integration mit Monitoring-Tools
    fetch(process.env.ALERT_WEBHOOK_URL, {
      method: 'POST',
      body: JSON.stringify({ text: 🚨 ${message} })
    });
  }
}

Fehler 3: Falsche Zeitstempel-Konvertierung

Problem: Tardis liefert Timestamps in Millisekunden, CryptoCompare in Sekunden. Falsche Annahmen führen zu Zeitverschiebungen von 1000x.

# ❌ FALSCH: Annahme beide nutzen Sekunden
from datetime import datetime

def broken_timestamp_conversion(timestamp):
    return datetime.fromtimestamp(timestamp)  # FALSCH für Tardis!


✅ RICHTIG: Anbieter-spezifische Konvertierung

class TimestampNormalizer:
    """Normalisiert Timestamps von verschiedenen Quellen"""
    
    @staticmethod
    def normalize_tardis_timestamp(ts_ms):
        """
        Tardis liefert Unix-Timestamp in Millisekunden.
        Konvertiert zu UTC datetime.
        """
        if ts_ms > 1e12:  # Millisekunden
            ts_ms = ts_ms / 1000
        return datetime.utcfromtimestamp(ts_ms)
    
    @staticmethod
    def normalize_cryptocompare_timestamp(ts_s):
        """
        CryptoCompare liefert Unix-Timestamp in Sekunden.
        Konvertiert zu UTC datetime.
        """
        return datetime.utcfromtimestamp(ts_s)
    
    @staticmethod
    def normalize_generic(timestamp, source='auto'):
        """
        Automatische Erkennung basierend auf Größenordnung.
        """
        if source == 'tardis':
            return TimestampNormalizer.normalize_tardis_timestamp(timestamp)
        elif source == 'cryptocompare':
            return TimestampNormalizer.normalize_cryptocompare_timestamp(timestamp)
        else:
            # Auto-Detection
            if timestamp > 1e12:
                return datetime.utcfromtimestamp(timestamp / 1000)
            return datetime.utcfromtimestamp(timestamp)


Anwendung

def process_tardis_trade(trade_data):
    """Verarbeitet Tardis Trade-Daten korrekt"""
    return {
        'symbol': trade_data['symbol'],
        'price': float(trade_data['price']),
        'volume': float(trade_data['volume']),
        'timestamp': TimestampNormalizer.normalize_tardis_timestamp(
            trade_data['timestamp']
        ),
        'trade_id': trade_data['id']
    }

def process_cryptocompare_ohlcv(ohlcv_data):
    """Verarbeitet CryptoCompare OHLCV-Daten korrekt"""
    return {
        'timestamp': TimestampNormalizer.normalize_cryptocompare_timestamp(
            ohlcv_data['time']
        ),
        'open': float(ohlcv_data['open']),
        'high': float(ohlcv_data['high']),
        'low': float(ohlcv_data['low']),
        'close': float(ohlcv_data['close']),
        'volume': float(ohlcv_data['volumefrom'])
    }

HolySheep AI: Die kosteneffiziente Alternative

Nach unserer Odyssee durch Tardis und CryptoCompare entdeckten wir HolySheep AI – und unsere Datenstrategie wurde revolutioniert. HolySheep AI bietet nicht nur Krypto-Marktdaten, sondern eine vollständige KI-Infrastruktur für Trading-Anwendungen.

Warum HolySheep wählen

Integration mit HolySheep AI

# HolySheep AI Integration für KI-gestützte Marktanalyse

Base URL: https://api.holysheep.ai/v1


import requests
import json

class HolySheepMarketAnalyzer:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
    
    def analyze_market_with_llm(self, market_data, symbol):
        """
        Verwendet ein KI-Modell zur Analyse von Marktdaten.
        Kostengünstig: DeepSeek V3.2 für nur $0.42 pro Million Tokens.
        """
        
        prompt = f"""Analysiere folgende Marktdaten für {symbol}:
        
Strukturierte Daten:
{json.dumps(market_data, indent=2)}

Identifiziere:
1. Aktueller Trend (bullish/bearish/neutral)
2. Key Support- und Resistance-Level
3. Empfohlene Trading-Strategie
4. Risikofaktoren

Antworte im JSON-Format."""

        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": "deepseek-v3.2",  # Günstigstes Modell
                "messages": [
                    {"role": "system", "content": "Du bist ein erfahrener Krypto-Analyst."},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.3,
                "max_tokens": 500
            }
        )
        
        if response.status_code != 200:
            raise RuntimeError(f"API-Fehler: {response.status_code}")
        
        result = response.json()
        return json.loads(result['choices'][0]['message']['content'])
    
    def get_realtime_quote(self, symbol):
        """
        Ruft Echtzeit-Kursdaten ab mit ultra-niedriger Latenz.
        """
        response = requests.get(
            f"{self.base_url}/market/quote",
            params={"symbol": symbol},
            headers={"Authorization": f"Bearer {self.api_key}"}
        )
        
        return response.json()


Nutzung

analyzer = HolySheepMarketAnalyzer(api_key='YOUR_HOLYSHEEP_API_KEY')


Hole Marktdaten

market_data = analyzer.get_realtime_quote('BTCUSDT')


KI-Analyse mit DeepSeek (nur $0.42/MTok!)

analysis = analyzer.analyze_market_with_llm(market_data, 'BTCUSDT')
print(f"Analyse: {analysis}")

Kaufempfehlung: Die richtige Wahl treffen

Nach intensiver Nutzung beider Systeme kann ich folgende Empfehlung geben:

Szenario Empfehlung Begründung
Budget < 500 USD/Monat CryptoCompare Free/Launch Kostengünstig, ausreichend für Prototypen
Budget 500-2000 USD HolySheep AI Beste Preis-Leistung, KI-Integration inklusive
Budget > 2000 USD, Tick-Level benötigt Tardis Einzige echte Tick-Level-Option
KI-gestützte Analyse benötigt HolySheep AI Natives LLM-Integration, 85%+ Ersparnis
Institutionelle Compliance Tardis Enterprise SLA, dedizierter Support

Meine finale Empfehlung

Für die meisten Teams, die ich berate, ist HolySheep AI die beste Wahl. Die Kombination

Verwandte Ressourcen

Verwandte Artikel