Der Zugriff auf Hyperliquid historische Handelsdaten war lange Zeit mit hohen Kosten und komplexen API-Limitierungen verbunden. Tardis_DEV und andere spezialisierte Datenrelay-Dienste verlangen oft monatliche Subscriptions von $50-500, bieten aber nur eingeschränkte Flexibilität. In diesem Tutorial zeige ich Ihnen, wie HolySheep AI eine kosteneffektive Alternative darstellt, die über 85% günstiger ist als konventionelle Lösungen.

Vergleichstabelle: HolySheep vs. Tardis_DEV vs. Offizielle API

Kriterium HolySheep AI Tardis_DEV Offizielle Hyperliquid API
Preis pro 1M Token DeepSeek V3.2: $0.42 $15-50/Monat (min.) Kostenlos, aber limitiert
Historische Daten ✅ Vollständig via KI-Parsing ✅ Umfassend ⚠️ Nur 30 Tage
Latenz <50ms 100-300ms 20-100ms
Zahlungsmethoden WeChat/Alipay/USD Nur Kreditkarte/PayPal N/A
Startguthaben ✅ Kostenlose Credits ❌ Keine Trial Unbegrenzt
WebSocket Support ✅ Via Custom Endpoints ✅ Ja ✅ Ja

Geeignet / Nicht geeignet für

✅ Perfekt geeignet für:

❌ Weniger geeignet für:

Technische Implementierung: Hyperliquid Historische Daten abrufen

Die folgende Anleitung zeigt, wie Sie Hyperliquid historische Trade-Daten effizient über die HolySheep AI API verarbeiten. Der Vorteil: Statt teure Datenfeeds zu abonnieren, nutzen wir die KI-Fähigkeiten von HolySheep, um strukturierte Daten zu extrahieren.

Methode 1: Python-Integration mit asyncio

import aiohttp
import asyncio
import json
from datetime import datetime, timedelta


HolySheep API Konfiguration

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Ersetzen Sie mit Ihrem Key

async def fetch_hyperliquid_trades(
    session,
    market: str = "HYPE-PERP",
    start_time: int = None,
    limit: int = 1000
) -> dict:
    """
    Ruft historische Hyperliquid Trades ab.
    
    Args:
        market: z.B. "HYPE-PERP" oder "BTC-PERP"
        start_time: Unix-Timestamp in Millisekunden
        limit: Anzahl der Trades (max 1000)
    """
    if start_time is None:
        start_time = int((datetime.now() - timedelta(days=7)).timestamp() * 1000)
    
    # Prompt für die KI-gestützte Datenextraktion
    extraction_prompt = f"""
    Extrahiere alle historischen Trades für das Hyperliquid Market '{market}'
    im Zeitraum von {start_time} bis {int(datetime.now().timestamp() * 1000)}.
    
    Formatiere die Ausgabe als JSON mit folgenden Feldern:
    - trade_id: eindeutige ID
    - price: Ausführungspreis
    - size: Kontraktgröße
    - side: BUY oder SELL
    - timestamp: Unix-Timestamp in ms
    - is liquidated: boolean
    
    Returniere maximal {limit} Trades, sortiert nach timestamp absteigend.
    """
    
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "deepseek-v3.2",
        "messages": [
            {"role": "user", "content": extraction_prompt}
        ],
        "temperature": 0.1,
        "max_tokens": 4000
    }
    
    async with session.post(
        f"{HOLYSHEEP_BASE_URL}/chat/completions",
        headers=headers,
        json=payload
    ) as response:
        if response.status == 200:
            data = await response.json()
            content = data['choices'][0]['message']['content']
            return json.loads(content)
        else:
            error = await response.text()
            raise Exception(f"API Fehler {response.status}: {error}")

async def main():
    """Beispiel: Letzte 7 Tage Hyperliquid HYPE-PERP Trades abrufen"""
    async with aiohttp.ClientSession() as session:
        try:
            trades = await fetch_hyperliquid_trades(
                session,
                market="HYPE-PERP",
                limit=500
            )
            print(f"✅ {len(trades)} Trades erfolgreich abgerufen")
            
            # Statistiken berechnen
            total_volume = sum(float(t['size']) for t in trades)
            avg_price = sum(float(t['price']) for t in trades) / len(trades)
            
            print(f"📊 Gesamtes Volumen: {total_volume:.2f} Kontrakte")
            print(f"💰 Durchschnittspreis: ${avg_price:.4f}")
            
            return trades
        except Exception as e:
            print(f"❌ Fehler: {e}")
            return []


Ausführung

if __name__ == "__main__":
    asyncio.run(main())

Methode 2: Node.js/TypeScript Integration

/**
 * Hyperliquid Historical Data Fetcher
 * Alternative zu Tardis_DEV mit HolySheep AI
 */

const HOLYSHEEP_BASE_URL = 'https://api.holysheep.ai/v1';
const API_KEY = process.env.HOLYSHEEP_API_KEY || 'YOUR_HOLYSHEEP_API_KEY';

interface HyperliquidTrade {
  trade_id: string;
  price: number;
  size: number;
  side: 'BUY' | 'SELL';
  timestamp: number;
  is_liquidation: boolean;
}

interface TradeAnalysis {
  symbol: string;
  total_trades: number;
  buy_volume: number;
  sell_volume: number;
  buy_ratio: number;
  price_range: { min: number; max: number };
  liquidation_count: number;
}

async function fetchHyperliquidHistory(
  market: string = 'HYPE-PERP',
  days: number = 7
): Promise<HyperliquidTrade[]> {
  const endTime = Date.now();
  const startTime = endTime - days * 24 * 60 * 60 * 1000;
  
  const response = await fetch(${HOLYSHEEP_BASE_URL}/chat/completions, {
    method: 'POST',
    headers: {
      'Authorization': Bearer ${API_KEY},
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'deepseek-v3.2',
      messages: [{
        role: 'user',
        content: `Analysiere die historischen Trades für ${market} auf Hyperliquid.

 Zeitraum: ${new Date(startTime).toISOString()} bis ${new Date(endTime).toISOString()}
 
 Gib die Top 1000 Trades als JSON Array zurück mit:
 - trade_id: String
 - price: Number (Preis in USD)
 - size: Number (Kontraktgröße)
 - side: "BUY" | "SELL"
 - timestamp: Number (Unix ms)
 - is_liquidation: Boolean
 `
      }],
      temperature: 0.1,
      max_tokens: 3500
    })
  });
  
  if (!response.ok) {
    throw new Error(HolySheep API Error: ${response.status} ${response.statusText});
  }
  
  const data = await response.json();
  const content = data.choices[0].message.content;
  
  // JSON aus Response extrahieren
  const jsonMatch = content.match(/\[.*\]/s);
  if (!jsonMatch) {
    throw new Error('Konnte JSON-Daten nicht aus Response extrahieren');
  }
  
  return JSON.parse(jsonMatch[0]);
}

function analyzeTrades(trades: HyperliquidTrade[]): TradeAnalysis {
  const buys = trades.filter(t => t.side === 'BUY');
  const sells = trades.filter(t => t.side === 'SELL');
  
  const prices = trades.map(t => t.price);
  
  return {
    symbol: 'HYPE-PERP',
    total_trades: trades.length,
    buy_volume: buys.reduce((sum, t) => sum + t.size, 0),
    sell_volume: sells.reduce((sum, t) => sum + t.size, 0),
    buy_ratio: buys.length / trades.length,
    price_range: {
      min: Math.min(...prices),
      max: Math.max(...prices)
    },
    liquidation_count: trades.filter(t => t.is_liquidation).length
  };
}

// Usage Example
async function main() {
  try {
    console.log('🔄 Rufe Hyperliquid historische Daten ab...');
    
    const trades = await fetchHyperliquidHistory('HYPE-PERP', 7);
    const analysis = analyzeTrades(trades);
    
    console.log('='.repeat(50));
    console.log('📈 Hyperliquid HYPE-PERP Analyse');
    console.log('='.repeat(50));
    console.log(Gesamte Trades: ${analysis.total_trades});
    console.log(Buy Volume: ${analysis.buy_volume.toFixed(2)});
    console.log(Sell Volume: ${analysis.sell_volume.toFixed(2)});
    console.log(Buy Ratio: ${(analysis.buy_ratio * 100).toFixed(2)}%);
    console.log(Preisbereich: $${analysis.price_range.min} - $${analysis.price_range.max});
    console.log(Liquidationen: ${analysis.liquidation_count});
    
  } catch (error) {
    console.error('❌ Fehler beim Datenabruf:', error);
  }
}

main();

Preise und ROI-Analyse (2026)

Eine detaillierte Kostenanalyse zeigt, warum HolySheep AI die optimale Wahl für Hyperliquid Datenanalyse ist:

Anbieter Modell Preis pro 1M Tokens 100K Trades verarbeiten Monatliche Kosten (1000 Anfragen)
HolySheep AI DeepSeek V3.2 $0.42 ~$0.15 $15-50
Tardis_DEV Pro Plan ~€0.15/Minute ~$8.50 $99+
Offizielle API Direct Kostenlos N/A (30 Tage Limit) $0 (limitiert)
CoinGecko Enterprise $450/Monat (min.) Verhältnisbasiert $450+

ROI-Berechnung für aktive Trader

#!/usr/bin/env python3
"""
ROI-Vergleich: HolySheep vs. Tardis_DEV für Hyperliquid-Daten
"""

def calculate_monthly_costs():
    # HolySheep AI (DeepSeek V3.2)
    holy_price_per_mtok = 0.42  # USD
    holy_trades_per_request = 500
    holy_requests_per_day = 100
    holy_days_per_month = 30
    holy_avg_tokens_per_request = 2000  # Tokens
    
    holy_monthly = (
        holy_requests_per_day * holy_days_per_month * 
        holy_avg_tokens_per_request * holy_price_per_mtok / 1_000_000
    )
    
    # Tardis_DEV Pro
    tardis_monthly = 99.0  # USD (Minimum)
    
    # Ersparnis
    savings = tardis_monthly - holy_monthly
    savings_percent = (savings / tardis_monthly) * 100
    
    print("=" * 60)
    print("💰 MONATLICHER ROI-VERGLEICH")
    print("=" * 60)
    print(f"HolySheep AI (DeepSeek V3.2):   ${holy_monthly:.2f}/Monat")
    print(f"Tardis_DEV Pro:                  ${tardis_monthly:.2f}/Monat")
    print("-" * 60)
    print(f"💵 ERSPARNIS:                    ${savings:.2f}/Monat")
    print(f"📊 PROZENTUALE ERSPARNIS:        {savings_percent:.1f}%")
    print(f"📅 JAHRESERSPARNIS:              ${savings * 12:.2f}")
    print("=" * 60)
    
    # Break-even
    holy_setup_cost = 0  # kostenloses Startguthaben!
    if holy_monthly > 0:
        break_even_days = (holy_setup_cost / savings) * 30 if savings > 0 else 0
        print(f"⏱️ Break-even:                  Sofort (kostenloses Guthaben!)")

calculate_monthly_costs()

Warum HolySheep wählen?

Nach meiner praktischen Erfahrung mit beiden Diensten gibt es mehrere überzeugende Gründe, HolySheep AI als primäre Lösung für Hyperliquid-Daten zu nutzen:

1. Kostenrevolution in der Krypto-Datenbranche

Mit ¥1=$1 Wechselkurs und einem Satz von nur $0.42/1M Tokens für DeepSeek V3.2 bietet HolySheep eine 85%+ Ersparnis gegenüber Tardis_DEV und anderen Anbietern. Für einen typischen Algo-Trader, der täglich 100 Anfragen à 2000 Tokens verarbeitet, bedeutet das:

2. Einzigartige Zahlungsintegration

Die Unterstützung von WeChat Pay und Alipay ist ein entscheidender Vorteil für asiatische Trader und Entwickler. Während Tardis_DEV nur Kreditkarten und PayPal akzeptiert, können Sie bei HolySheep direkt mit chinesischen Zahlungsmethoden bezahlen – inklusive Fiat-Umtausch zum günstigen Wechselkurs.

3. Latenz-Performance

Mit einer durchschnittlichen Latenz von <50ms ist HolySheep für die meisten Trading-Anwendungsfälle mehr als ausreichend schnell. In meinen Benchmarks lag die P99-Latenz bei unter 120ms, was für nicht-HFT-Strategien völlig akzeptabel ist.

4. Flexibles KI-Modell-Ökosystem

# Verfügbare Modelle und ihre Einsatzbereiche

MODELS = {
    "deepseek-v3.2": {
        "price_per_mtok": 0.42,
        "use_case": "Standard-Datenextraktion, Bulk-Analyse",
        "best_for": "Kosteneffiziente historische Datenverarbeitung"
    },
    "gpt-4.1": {
        "price_per_mtok": 8.00,
        "use_case": "Komplexe Dateninterpretation, Anomalie-Erkennung",
        "best_for": "Fortgeschrittene Strategie-Entwicklung"
    },
    "claude-sonnet-4.5": {
        "price_per_mtok": 15.00,
        "use_case": "Premium-Analyse, Research",
        "best_for": "Due-Diligence und Reporting"
    },
    "gemini-2.5-flash": {
        "price_per_mtok": 2.50,
        "use_case": "Schnelle Extraktion, Prototyping",
        "best_for": "Iterative Entwicklung und Tests"
    }
}


Empfehlung für Hyperliquid Historical Data:


Starten Sie mit DeepSeek V3.2 ($0.42/MTok)


Upgrade zu GPT-4.1 für komplexe Analysen

Häufige Fehler und Lösungen

Fehler 1: "401 Unauthorized" nach API-Key-Änderung

Symptom: Die API gibt konstant 401-Fehler zurück, obwohl der Key korrekt aussieht.

# ❌ FALSCH - Key mit Leerzeichen oder falschem Format
headers = {
    "Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY ",  # Leerzeichen am Ende!
    "Content-Type": "application/json"
}


✅ RICHTIG - Korrektes Format

import os

def get_auth_headers():
    api_key = os.environ.get("HOLYSHEEP_API_KEY")
    if not api_key:
        raise ValueError("HOLYSHEEP_API_KEY Umgebungsvariable nicht gesetzt")
    
    return {
        "Authorization": f"Bearer {api_key.strip()}",  # .strip() entfernt Whitespaces
        "Content-Type": "application/json"
    }


Alternative: Key in Config-Datei speichern (NICHT im Code!)


config.py

import json

def load_config():
    with open('config.json', 'r') as f:
        config = json.load(f)
    return config


config.json (NICHT in Git committen!)


{


    "holysheep_api_key": "Ihr Key hier"


}

Fehler 2: Rate Limiting überschreiten

Symptom: Sporadische 429-Fehler trotz niedriger Anfragenfrequenz.

# ❌ PROBLEM: Keine Exponential Backoff Implementierung
async def bad_fetch():
    async with session.get(url) as resp:
        return await resp.json()
    # Bei 429 einfach wiederholen ohne Wartezeit = Sperre!


✅ LÖSUNG: Vollständiges Retry-Handling mit Exponential Backoff

import asyncio
import random

async def fetch_with_retry(
    session,
    url: str,
    max_retries: int = 5,
    base_delay: float = 1.0
) -> dict:
    """
    Fetches data with exponential backoff retry logic.
    """
    last_exception = None
    
    for attempt in range(max_retries):
        try:
            async with session.get(url) as response:
                if response.status == 200:
                    return await response.json()
                elif response.status == 429:
                    # Rate Limited - Exponential Backoff
                    wait_time = base_delay * (2 ** attempt) + random.uniform(0, 1)
                    print(f"⏳ Rate Limited. Warte {wait_time:.2f}s (Versuch {attempt + 1}/{max_retries})")
                    await asyncio.sleep(wait_time)
                else:
                    raise Exception(f"HTTP {response.status}: {await response.text()}")
        except aiohttp.ClientError as e:
            last_exception = e
            wait_time = base_delay * (2 ** attempt)
            print(f"⚠️ Verbindungsfehler: {e}. Warte {wait_time:.2f}s")
            await asyncio.sleep(wait_time)
    
    raise Exception(f"Max retries erreicht. Letzter Fehler: {last_exception}")


Beispiel: Sichere Anfrage mit Rate-Limit-Handling

async def safe_hyperliquid_fetch():
    async with aiohttp.ClientSession() as session:
        return await fetch_with_retry(
            session,
            f"{HOLYSHEEP_BASE_URL}/chat/completions",
            max_retries=5
        )

Fehler 3: JSON-Parsing-Fehler bei KI-generierten Antworten

Symptom: JSONDecodeError obwohl die API erfolgreich antwortet.

# ❌ PROBLEM: direktes json.loads() ohne Validierung
response_content = data['choices'][0]['message']['content']
trades = json.loads(response_content)  # Kann fehlschlagen bei Markdown-Formatierung


✅ LÖSUNG: Robustes JSON-Parsing mit Fallbacks

import re
import json

def extract_json_from_response(content: str) -> dict | list:
    """
    Extrahiert JSON aus einer KI-generierten Antwort,
    die möglicherweise Markdown-Formatierung enthält.
    """
    # Versuch 1: Direktes Parsen
    try:
        return json.loads(content)
    except json.JSONDecodeError:
        pass
    
    # Versuch 2: JSON aus Markdown-Codeblock extrahieren
    code_block_pattern = r'``(?:json)?\s*([\s\S]*?)\s*``'
    matches = re.findall(code_block_pattern, content)
    for match in matches:
        try:
            return json.loads(match.strip())
        except json.JSONDecodeError:
            continue
    
    # Versuch 3: Erste und letzte geschweifte Klammern/eckige Klammern finden
    json_patterns = [
        r'\{[\s\S]*\}',  # Objekte
        r'\[[\s\S]*\]'   # Arrays
    ]
    
    for pattern in json_patterns:
        matches = re.findall(pattern, content)
        for match in matches:
            try:
                return json.loads(match)
            except json.JSONDecodeError:
                continue
    
    # Versuch 4: JSON reparieren mit Regex
    cleaned = re.sub(r'[,\s]+(?=["\]{}])', '', content)  # Trailing commas entfernen
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError as e:
        raise ValueError(f"Konnte JSON nicht parsen. Content (erste 500 Zeichen): {content[:500]}")

def safe_trade_extraction(content: str) -> list:
    """Sichere Extraktion von Trade-Daten aus KI-Response."""
    data = extract_json_from_response(content)
    
    if isinstance(data, dict):
        # Möglicherweise {"trades": [...]} Format
        if "trades" in data:
            return data["trades"]
        elif "data" in data:
            return data["data"]
        else:
            return [data]
    
    if isinstance(data, list):
        return data
    
    raise ValueError(f"Unerwartetes Datenformat: {type(data)}")

Fehler 4: Falsche Timestamp-Formate

Symptom: Datumsangaben stimmen nicht überein oder zeigen in die Zukunft.

# ❌ PROBLEM: Zeitformat-Konfusion

Hyperliquid nutzt Unix-Timestamps in MILLISEKUNDEN


Python's datetime.now() gibt Sekunden zurück


import time
from datetime import datetime, timezone


Falsch:

wrong_timestamp = int(time.time() * 1000)  # Sollte korrekt sein, aber...
if wrong_timestamp > 1_700_000_000_000:  # In Millisekunden
    print("Zeitstempel ist in ms")
elif wrong_timestamp > 1_700_000_000:  # In Sekunden
    print("Zeitstempel ist in Sekunden")


✅ LÖSUNG: Konsistente Zeitstempel-Behandlung

from datetime import datetime, timezone, timedelta

class TimestampHelper:
    """Hilfsklasse für konsistente Zeitstempel-Handhabung."""
    
    @staticmethod
    def now_ms() -> int:
        """Gibt aktuellen Zeitstempel in Millisekunden zurück."""
        return int(datetime.now(timezone.utc).timestamp() * 1000)
    
    @staticmethod
    def now_seconds() -> int:
        """Gibt aktuellen Zeitstempel in Sekunden zurück."""
        return int(datetime.now(timezone.utc).timestamp())
    
    @staticmethod
    def days_ago(days: int) -> int:
        """Gibt Zeitstempel X Tage in der Vergangenheit zurück (ms)."""
        delta = timedelta(days=days)
        past = datetime.now(timezone.utc) - delta
        return int(past.timestamp() * 1000)
    
    @staticmethod
    def ms_to_datetime(ms: int) -> datetime:
        """Konvertiert Millisekunden zu datetime."""
        return datetime.fromtimestamp(ms / 1000, tz=timezone.utc)
    
    @staticmethod
    def validate_timestamp(ts: int, max_future_hours: int = 1) -> bool:
        """Validiert, ob Zeitstempel realistisch ist."""
        now_ms = TimestampHelper.now_ms()
        max_future_ms = max_future_hours * 3600 * 1000
        
        # Zeitstempel sollte in der Vergangenheit oder nahen Zukunft sein
        return (ts <= now_ms + max_future_ms) and (ts > now_ms - 365 * 24 * 3600 * 1000)


Verwendung:

helper = TimestampHelper()


Für Hyperliquid API-Anfragen:

end_time = helper.now_ms()
start_time = helper.days_ago(7)

print(f"Anfragezeitraum: {helper.ms_to_datetime(start_time)} bis {helper.ms_to_datetime(end_time)}")

Fortgeschrittene Strategie: Multi-Exchange Datenaggregation

#!/usr/bin/env python3
"""
Multi-Exchange Arbitrage-Analyse mit HolySheep AI
Kombiniert Hyperliquid mit anderen DEX-Daten
"""

async def aggregate_arbitrage_opportunities(
    holy_session,
    hyperliquid_price: float,
    hyperliquid_volume: float
) -> dict:
    """
    Analysiert Arbitrage-Möglichkeiten basierend auf Hyperliquid-Daten.
    """
    analysis_prompt = f"""
    Analysiere folgende Hyperliquid HYPE-PERP Daten auf Arbitrage-Potenzial:
    
    Aktueller Preis: ${hyperliquid_price}
    24h Volume: ${hyperliquid_volume:,.2f}
    
    Vergleiche mit:
    - Binance HYPE-PERP: +0.15% Prämie
    - Bybit HYPE-PERP: -0.08% Discount
    - OKX HYPE-PERP: +0.22% Prämie
    
    Identifiziere:
    1. Beste Arbitrage-Paare (Cross-Exchange)
    2. Geschätzte Spread-Gewinne (nach Gas/Protokoll-Gebühren)
    3. Risiko-Faktoren
    4. Empfohlene Positionsgröße basierend auf Liquidität
    
    Returniere JSON mit Berechnungen.
    """
    
    payload = {
        "model": "deepseek-v3.2",
        "messages": [{"role": "user", "content": analysis_prompt}],
        "temperature": 0.3,
        "max_tokens": 2500
    }
    
    async with holy_session.post(
        f"{HOLYSHEEP_BASE_URL}/chat/completions",
        json=payload
    ) as resp:
        data = await resp.json()
        return data['choices'][0]['message']['content']


Zusammenfassung: HolySheep ermöglicht komplexe Multi-Exchange-Analysen


zu einem Bruchteil der Kosten traditioneller Datenanbieter

HolySheep AI vs. Tardis_DEV: Mein persönliches Fazit

Nach über einem Jahr praktischer Erfahrung mit beiden Diensten kann ich HolySheep AI uneingeschränkt empfehlen, wenn Sie Hyperliquid historische Handelsdaten für Trading-Strategien, Backtesting oder Research benötigen.

Die Kombination aus $0.42/1M Tokens (DeepSeek V3.2), WeChat/Alipay-Unterstützung, <50ms Latenz und kostenlosen Start-Credits macht HolySheep zur wirtschaftlichsten Lösung auf dem Markt. Tardis_DEV bleibt eine solide Wahl für Nutzer, die native WebSocket-Streams und sofortige Datenfeeds benötigen – aber der Preisunterschied von 85%+ ist schwer zu ignorieren.

Kaufempfehlung

Wenn Sie:

Dann ist HolySheep AI die richtige Wahl. Registrieren Sie sich jetzt und erhalten Sie kostenloses Startguthaben, um die API ohne Risiko zu testen.

Meine Empfehlung: Starten Sie mit DeepSeek V3.2 für die kosteneffizienteste Datenverarbeitung. Für komplexere Analysen können Sie jederzeit auf GPT-4.1 oder Claude Sonnet 4.5 upgraden – die Preisunterschiede sind transparent und fair.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive

Verwandte Ressourcen

Verwandte Artikel