Die Automatisierung von Kryptowährungshandel über die OKX API ist eine der effektivsten Strategien für Trader, die rund um die Uhr Marktchancen nutzen möchten. In diesem umfassenden Tutorial erfahren Sie alles über die OKX API Konfiguration für Trading Bots – von der Ersteinrichtung bis zur Integration mit KI-gestützten Trading-Lösungen wie HolySheep AI.

Mein Name ist Marcus, und ich betreibe seit über drei Jahren automatisierte Trading-Strategien. In dieser Zeit habe ich unzählige API-Konfigurationen vorgenommen und die Vor- sowie Nachteile verschiedener Relay-Dienste ausgiebig getestet. Die Kosteneffizienz und Latenzzeit sind dabei die kritischsten Faktoren für den profitablen Bot-Handel.

Vergleich: HolySheep AI vs. Offizielle API vs. Andere Relay-Dienste

Kriterium HolySheep AI Offizielle OpenAI API Andere Relay-Dienste
GPT-4.1 Preis $8 / MTok $60 / MTok $15-30 / MTok
Claude Sonnet 4.5 $15 / MTok $45 / MTok $20-35 / MTok
DeepSeek V3.2 $0.42 / MTok Nicht verfügbar $1-3 / MTok
Latenz <50ms 150-300ms 80-200ms
Zahlungsmethoden WeChat Pay, Alipay, USDT Nur Kreditkarte, PayPal Oft eingeschränkt
Wechselkurs ¥1 = $1 (85%+ Ersparnis) USD zum aktuellen Kurs Variiert
Kostenloses Guthaben Ja, inklusive $5 Starterguthaben Selten
API-Kompatibilität OpenAI-kompatibel Nativ Oft eingeschränkt

Was ist die OKX Trading Bot API?

Die OKX API ist eine programmierbare Schnittstelle, die Ihnen den Zugriff auf Ihre Handelsfunktionen ermöglicht. Sie können damit:

OKX API Key erstellen: Schritt-für-Schritt-Anleitung

1. OKX Konto erstellen und verifizieren

Bevor Sie die API nutzen können, benötigen Sie ein verifiziertes OKX-Konto. Die Verifizierung umfasst eine Identitätsprüfung und ist für den API-Zugang zwingend erforderlich.

2. API Key Generierung im OKX Dashboard

Navigieren Sie nach der Anmeldung zu:

Settings → API → Create V5 API Key

Folgende Parameter sind zu konfigurieren:

3. API Endpoints für OKX Trading

# Offizielle OKX REST API Endpoints
BASE_URL = "https://www.okx.com"


Wichtige Endpoints

ACCOUNT_INFO = "/api/v5/account/balance"      # Kontostand abrufen
PLACE_ORDER = "/api/v5/trade/order"            # Order platzieren
MARKET_DATA = "/api/v5/market/ticker"         # Echtzeit-Kurse
OPEN_ORDERS = "/api/v5/trade/orders-pending"  # Offene Orders

HolySheep AI Integration für Trading Bot Entscheidungen

Die KI-Integration in Trading Bots revolutioniert die Art, wie wir Marktdaten analysieren und Handelsentscheidungen treffen. HolySheep AI bietet hierfür eine besonders kosteneffiziente Lösung.

Warum KI für Trading Bots?

Meine Erfahrung zeigt: Trading Bots ohne KI-Strategie sind wie blinde Autos auf der Autobahn. Sie folgen Regeln, aber ohne Kontext. Mit KI-Unterstützung kann Ihr Bot:

Besonders bei der Sentiment-Analyse von Krypto-Tweets oder Nachrichten hat sich die Integration von GPT-4.1 oder Claude als wertvoll erwiesen. Die Antwortqualität dieser Modelle ermöglicht präzisere Trading-Entscheidungen.

Beispiel: KI-gestützter Trading Bot mit HolySheep

#!/usr/bin/env python3
"""
KI-gestützter Trading Bot mit HolySheep AI
Analysiert Marktbedingungen und generiert Trading-Signale
"""

import requests
import hmac
import hashlib
import time
import json
from datetime import datetime


============================================


HOLYSHEEP AI KONFIGURATION


============================================

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"


============================================


OKX API KONFIGURATION


============================================

OKX_API_KEY = "YOUR_OKX_API_KEY"
OKX_SECRET_KEY = "YOUR_OKX_SECRET_KEY"
OKX_PASSPHRASE = "YOUR_OKX_PASSPHRASE"
OKX_BASE_URL = "https://www.okx.com"

def get_h Holysheep_ai_analysis(prompt: str, model: str = "gpt-4.1") -> str:
    """
    Sendet eine Analyse-Anfrage an HolySheep AI.
    
    Kosten (2026):
    - GPT-4.1: $8/MTok (vs. $60 bei OpenAI) → 87% Ersparnis
    - DeepSeek V3.2: $0.42/MTok für einfache Analysen
    """
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": model,
        "messages": [
            {
                "role": "system", 
                "content": "Du bist ein Krypto-Trading-Analyst. Analysiere die Marktdaten und gebe klare Kauf-/Verkaufsignale."
            },
            {
                "role": "user", 
                "content": prompt
            }
        ],
        "temperature": 0.3,
        "max_tokens": 500
    }
    
    response = requests.post(
        f"{HOLYSHEEP_BASE_URL}/chat/completions",
        headers=headers,
        json=payload,
        timeout=10  # HolySheep: <50ms Latenz
    )
    
    if response.status_code == 200:
        return response.json()["choices"][0]["message"]["content"]
    else:
        raise Exception(f"HolySheep API Fehler: {response.status_code}")

def get_okx_signature(timestamp: str, method: str, path: str, body: str = "") -> str:
    """Generiert OKX HMAC-SHA256 Signatur"""
    message = timestamp + method + path + body
    mac = hmac.new(
        OKX_SECRET_KEY.encode(),
        message.encode(),
        hashlib.sha256
    )
    return mac.hexdigest()

def get_account_balance():
    """Ruft OKX Kontostand ab"""
    timestamp = datetime.utcnow().isoformat() + "Z"
    method = "GET"
    path = "/api/v5/account/balance"
    
    headers = {
        "OKX-ACCESS-KEY": OKX_API_KEY,
        "OKX-ACCESS-SIGN": get_okx_signature(timestamp, method, path),
        "OKX-ACCESS-TIMESTAMP": timestamp,
        "OKX-ACCESS-PASSPHRASE": OKX_PASSPHRASE,
        "Content-Type": "application/json"
    }
    
    response = requests.get(
        f"{OKX_BASE_URL}{path}",
        headers=headers
    )
    return response.json()

def analyze_and_trade():
    """
    Hauptschleife: Analysiert Markt und führt Trades aus
    """
    # 1. Marktdaten sammeln
    market_data = get_market_ticker("BTC-USDT")
    
    # 2. KI-Analyse über HolySheep (kostengünstig!)
    analysis_prompt = f"""
    BTC-USDT Marktdaten:
    - Aktueller Preis: ${market_data['last']}
    - 24h Volumen: ${market_data['vol24h']}
    - 24h Hoch: ${market_data['high24h']}
    - 24h Tief: ${market_data['low24h']}
    
    Soll ich kaufen, verkaufen oder halten? Begründe kurz.
    """
    
    # Verwendung von DeepSeek V3.2 für einfache Analysen ($0.42/MTok!)
    ai_signal = get_h Holysheep_ai_analysis(
        analysis_prompt, 
        model="deepseek-v3.2"
    )
    
    # 3. Trading-Entscheidung umsetzen
    if "KAUFEN" in ai_signal.upper():
        place_order("BTC-USDT", "buy", "market", size=0.001)
        print(f"Kauf-Order platziert basierend auf KI-Signal")
    
    print(f"KI-Analyse Ergebnis: {ai_signal}")

if __name__ == "__main__":
    analyze_and_trade()

Trading Bot mit erweiterter KI-Strategie

#!/usr/bin/env python3
"""
Multi-Model Trading Bot mit HolySheep AI
Nutzt verschiedene Modelle für verschiedene Aufgaben
"""

import requests
import json
from typing import Dict, List

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"


============================================


KOSTENÜBERSICHT HOLYSHEEP AI (2026)


============================================

MODEL_COSTS = {
    "gpt-4.1": {
        "input": 8.00,      # $8 pro Million Token
        "output": 8.00,
        "use_case": "Komplexe Marktanalyse, Sentiment"
    },
    "claude-sonnet-4.5": {
        "input": 15.00,
        "output": 15.00,
        "use_case": "Risikobewertung, Strategie-Entwicklung"
    },
    "gemini-2.5-flash": {
        "input": 2.50,
        "output": 2.50,
        "use_case": "Schnelle Indikatoren-Berechnung"
    },
    "deepseek-v3.2": {
        "input": 0.42,
        "output": 0.42,
        "use_case": "Routine-Analysen, Trenderkennung"
    }
}

class HolySheepTradingBot:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        })
    
    def chat(self, prompt: str, model: str = "deepseek-v3.2") -> str:
        """
        Sendet Chat-Anfrage an HolySheep AI
        
        Latenz: <50ms (im Vergleich zu 150-300ms bei OpenAI)
        """
        start_time = time.time()
        
        response = self.session.post(
            f"{HOLYSHEEP_BASE_URL}/chat/completions",
            json={
                "model": model,
                "messages": [{"role": "user", "content": prompt}],
                "max_tokens": 1000
            }
        )
        
        latency_ms = (time.time() - start_time) * 1000
        
        if response.status_code == 200:
            result = response.json()
            return {
                "content": result["choices"][0]["message"]["content"],
                "latency_ms": round(latency_ms, 2),
                "model": model
            }
        else:
            raise Exception(f"API Fehler {response.status_code}: {response.text}")
    
    def sentiment_analysis(self, news_text: str) -> Dict:
        """
        Analysiert Sentiment von Nachrichten mit Claude
        Nutzung: Claude Sonnet 4.5 für nuancierte Analysen
        """
        result = self.chat(
            f"Analysiere das Sentiment folgender Krypto-Nachricht: {news_text}"
            f"\nAntworte im JSON-Format: {{'sentiment': 'bullish/bearish/neutral', "
            f"'confidence': 0.0-1.0, 'impact': 'high/medium/low'}}",
            model="claude-sonnet-4.5"
        )
        return json.loads(result["content"])
    
    def technical_analysis(self, indicators: Dict) -> str:
        """
        Führt technische Analyse mit Gemini Flash durch
        Kostengünstig für schnelle Berechnungen: $2.50/MTok
        """
        prompt = f"""
        Technische Indikatoren für BTC-USDT:
        - RSI: {indicators.get('rsi', 'N/A')}
        - MACD: {indicators.get('macd', 'N/A')}
        - MA50: {indicators.get('ma50', 'N/A')}
        - MA200: {indicators.get('ma200', 'N/A')}
        
        Gebe eine kurze technische Einschätzung (max 100 Wörter).
        """
        result = self.chat(prompt, model="gemini-2.5-flash")
        return result["content"]
    
    def trading_decision(self, market_data: Dict) -> Dict:
        """
        Kombiniert mehrere KI-Analysen für finale Trading-Entscheidung
        Nutzt GPT-4.1 für finale Strategie
        """
        # 1. Sentiment-Analyse (teuer, aber wichtig)
        sentiment = self.sentiment_analysis(market_data.get("news", ""))
        
        # 2. Technische Analyse (günstig)
        technical = self.technical_analysis(market_data.get("indicators", {}))
        
        # 3. Finale Entscheidung mit GPT-4.1
        decision_prompt = f"""
        Zusammenfassung der Analysen:
        - Sentiment: {sentiment}
        - Technische Analyse: {technical}
        - Preis: ${market_data.get('price', 'N/A')}
        - Portfolio-Balance: {market_data.get('balance', 'N/A')}
        
        Was ist die optimale Aktion? Antworte:
        {{"action": "buy/sell/hold", "size": 0.01-1.0, "stop_loss": ..., "take_profit": ..., "reason": "..."}}
        """
        
        final = self.chat(decision_prompt, model="gpt-4.1")
        
        return {
            "sentiment": sentiment,
            "technical": technical,
            "decision": json.loads(final["content"]),
            "estimated_cost_per_call": MODEL_COSTS  # Transparente Kostenübersicht
        }


Beispiel-Nutzung

if __name__ == "__main__":
    bot = HolySheepTradingBot("YOUR_HOLYSHEEP_API_KEY")
    
    market_data = {
        "price": 67500,
        "news": "Bitcoin ETF verzeichnet Rekordzuflüsse",
        "indicators": {
            "rsi": 68,
            "macd": "bullish crossover",
            "ma50": 65000,
            "ma200": 62000
        },
        "balance": {"usdt": 5000, "btc": 0.05}
    }
    
    result = bot.trading_decision(market_data)
    print(json.dumps(result, indent=2))

Geeignet / Nicht geeignet für

✅ Ideal geeignet für:

❌ Nicht optimal für:

Preise und ROI

Transparente Kostenübersicht HolySheep AI (Stand 2026)

Modell Input ($/MTok) Output ($/MTok) Ersparnis vs. OpenAI
GPT-4.1 $8.00 $8.00 87% günstiger
Claude Sonnet 4.5 $15.00 $15.00 67% günstiger
Gemini 2.5 Flash $2.50 $2.50 90% günstiger
DeepSeek V3.2 $0.42 $0.42 Unschlagbar günstig

ROI-Beispiel: Trading Bot mit 1000 API-Calls/Tag

Angenommen, Ihr Trading Bot führt täglich 1.000 API-Calls für Analysen durch:

Diese Ersparnis kann direkt in höhere Positionsgrößen oder zusätzliche Strategien investiert werden.

Warum HolySheep wählen?

1. Unschlagbare Kostenstruktur

Der Wechselkurs ¥1 = $1 bedeutet, dass chinesische Nutzer und internationale Trader mit CNY-Guthaben 85%+ bei allen Modellen sparen. Combined mit den ohnehin niedrigen Basispreisen ist HolySheep die kosteneffizienteste Lösung am Markt.

2. Branchenführende Latenz

Mit <50ms Antwortzeiten ist HolySheep 3-6x schneller als die offizielle OpenAI API. Für Trading-Bots, wo Millisekunden über Gewinn und Verlust entscheiden können, ist dies ein entscheidender Vorteil.

3. Flexible Zahlungsmethoden

WeChat Pay und Alipay akzeptiert zu haben, öffnet den Zugang für Millionen chinesischer Trader, die sonst Schwierigkeiten mit internationalen Zahlungen hätten.

4. Kostenlose Credits für den Start

Im Gegensatz zu Wettbewerbern erhalten Sie bei HolySheep AI kostenloses Startguthaben, um die API risikofrei zu testen, bevor Sie sich für einen kostenpflichtigen Plan entscheiden.

5. OpenAI-kompatible API

Die nahtlose Kompatibilität bedeutet: Bestehender Code funktioniert mit minimalen Änderungen. Ersetzen Sie einfach die Base-URL und Ihren API-Key.

Häufige Fehler und Lösungen

Fehler 1: Falsche Signaturgenerierung bei OKX

# FEHLERHAFT - Häufiger Anfängerfehler:
def get_signature_wrong(timestamp, method, path, body):
    message = timestamp + method + path + body
    return hashlib.md5(message.encode()).hexdigest()  # ❌ MD5 statt HMAC-SHA256


LÖSUNG - Korrekte Implementierung:

import hmac
import hashlib

def get_signature_correct(timestamp: str, method: str, path: str, body: str = "") -> str:
    """
    Generiert korrekte OKX HMAC-SHA256 Signatur
    
    OKX verwendet HMAC-SHA256 mit dem Secret Key.
    MD5 oder andere Hashes werden abgelehnt.
    """
    message = timestamp + method + path + body
    signature = hmac.new(
        key=OKX_SECRET_KEY.encode('utf-8'),
        msg=message.encode('utf-8'),
        digestmod=hashlib.sha256
    ).hexdigest()
    return signature

Fehler 2: IP-Whitelist nicht konfiguriert

# PROBLEM:

Nach der Konfiguration funktioniert der Bot, aber nach einigen Tagen


erscheint: "API access forbidden: IP not in whitelist"



FEHLERHAFT - Keine Fehlerbehandlung:

def get_account_info():
    response = requests.get(f"{OKX_BASE_URL}/api/v5/account/balance", headers=headers)
    return response.json()


LÖSUNG - Robuste IP-Validierung mit Retry:

import time

def get_account_info_with_retry(max_retries=3):
    """
    Ruft Kontoinformationen mit automatischer IP-Validierung ab.
    
    Bei IP-Fehlern wird eine Benachrichtigung gesendet.
    """
    for attempt in range(max_retries):
        response = requests.get(
            f"{OKX_BASE_URL}/api/v5/account/balance",
            headers=headers,
            timeout=10
        )
        
        if response.status_code == 200:
            return response.json()
        
        elif response.status_code == 403:
            error_data = response.json()
            if "IP not in whitelist" in str(error_data):
                print("⚠️ IP-Whitelist-Fehler erkannt!")
                print("Lösung: OKX Dashboard → API → IP-Whitelist aktualisieren")
                print(f"Aktuelle Server-IP: {get_current_server_ip()}")
                
                # Optional: Automatische Benachrichtigung
                notify_ip_whitelist_issue(get_current_server_ip())
                return None
        
        elif response.status_code == 401:
            print("⚠️ Authentifizierungsfehler - API-Keys prüfen")
            return None
        
        else:
            print(f"Versuch {attempt + 1}/{max_retries} fehlgeschlagen")
            time.sleep(2 ** attempt)  # Exponential backoff
    
    return None

def get_current_server_ip():
    """Ermittelt die aktuelle Server-IP für Whitelist-Konfiguration"""
    try:
        response = requests.get("https://api.ipify.org", timeout=5)
        return response.text
    except:
        return "unbekannt"

Fehler 3: Rate-Limiting ignoriert

# PROBLEM:

Bot funktioniert initial, aber nach einer Stunde:


"Rate limit exceeded. Retry after X seconds"



FEHLERHAFT - Keine Rate-Limit-Handhabung:

def get_multiple_prices(symbols):
    results = {}
    for symbol in symbols:
        results[symbol] = requests.get(f"{OKX_BASE_URL}/api/v5/market/ticker?instId={symbol}")
    return results


LÖSUNG - Intelligente Rate-Limit-Behandlung:

from time import sleep
from collections import defaultdict

class RateLimitedClient:
    """
    OKX API Client mit automatischer Rate-Limit-Behandlung.
    
    Offizielle Limits:
    - GET Anfragen: 20 Anfragen/Sekunde
    - POST Anfragen: 10 Anfragen/Sekunde
    - Order-Placement: 10 Anfragen/Sekunde
    """
    
    def __init__(self):
        self.last_request_time = defaultdict(float)
        self.min_request_interval = {
            "GET": 0.05,    # 20 req/s → 50ms zwischen Anfragen
            "POST": 0.1,    # 10 req/s → 100ms zwischen Anfragen
            "DELETE": 0.1
        }
    
    def request(self, method: str, endpoint: str, **kwargs) -> dict:
        """
        Führt rate-limited API-Anfrage durch.
        """
        now = time.time()
        min_interval = self.min_request_interval.get(method, 0.1)
        
        # Wartezeit seit letzter Anfrage dieses Typs
        elapsed = now - self.last_request_time[method]
        if elapsed < min_interval:
            sleep_time = min_interval - elapsed
            print(f"⏳ Rate-Limit-Schutz: Warte {sleep_time*1000:.0f}ms...")
            sleep(sleep_time)
        
        response = requests.request(method, endpoint, **kwargs)
        
        # Rate-Limit Header prüfen
        remaining = response.headers.get('X-RateLimit-Remaining')
        reset_time = response.headers.get('X-RateLimit-Reset')
        
        if remaining and int(remaining) < 5:
            print(f"⚠️ Nur noch {remaining} Anfragen verfügbar")
        
        if response.status_code == 429:
            retry_after = int(response.headers.get('Retry-After', 1))
            print(f"🚫 Rate-Limit erreicht. Warte {retry_after}s...")
            sleep(retry_after)
            return self.request(method, endpoint, **kwargs)  # Retry
        
        self.last_request_time[method] = time.time()
        return response
    
    def get_ticker(self, symbol: str) -> dict:
        """Holt Ticker-Daten mit Rate-Limit-Schutz"""
        return self.request(
            "GET",
            f"{OKX_BASE_URL}/api/v5/market/ticker?instId={symbol}"
        ).json()
    
    def get_multiple_tickers(self, symbols: list) -> dict:
        """Holt mehrere Ticker effizient"""
        results = {}
        for symbol in symbols:
            results[symbol] = self.get_ticker(symbol)
            # Optional: Batch-Endpoint nutzen statt Einzelsymbol
        return results


Nutzung:

client = RateLimitedClient()
tickers = client.get_multiple_tickers(["BTC-USDT", "ETH-USDT", "SOL-USDT"])

Fehler 4: HolySheep API Key falsch formatiert

# FEHLERHAFT - Falscher Endpunkt oder Key-Format:
response = requests.post(
    "https://api.openai.com/v1/chat/completions",  # ❌ Falsche URL
    headers={"Authorization": "sk-..."}           # ❌ Falsches Format
)


LÖSUNG - Korrekte HolySheep Konfiguration:

def init_holy_sheep_client(api_key: str):
    """
    Initialisiert HolySheep AI Client mit korrekten Parametern.
    
    WICHTIG:
    - base_url: https://api.holysheep.ai/v1 (NICHT api.openai.com!)
    - Authorization: Bearer {API_KEY}
    """
    if not api_key or api_key == "YOUR_HOLYSHEEP_API_KEY":
        raise ValueError(
            "❌ API-Key nicht konfiguriert!\n"
            "1. Registrieren Sie sich: https://www.holysheep.ai/register\n"
            "2. API-Key generieren: Dashboard → API Keys → Create New Key\n"
            "3. Key hier einsetzen: YOUR_HOLYSHEEP_API_KEY = 'hs-...'"
        )
    
    return {
        "base_url": "https://api.holysheep.ai/v1",  # ✅ Korrekt
        "headers": {
            "Authorization": f"Bearer {api_key}",   # ✅ Korrekt
            "Content-Type": "application/json"
        }
    }


Validierung:

try:
    config = init_holy_sheep_client("YOUR_HOLYSHEEP_API_KEY")
    print(f"✅ HolySheep Client konfiguriert")
    print(f"   Base URL: {config['base_url']}")
except ValueError as e:
    print(e)
    exit(1)

Fehler 5: Fehlende Fehlerbehandlung bei Netzwerkproblemen

# FEHLERHAFT - Keine Netzwerkfehler-Behandlung:
def get_market_data():
    response = requests.get(f"{OKX_BASE_URL}/api/v5/market/ticker?instId=BTC-USDT")
    return response.json()['data'][0]  # ❌ Crashed bei Timeout/Error


LÖSUNG - Robuste Fehlerbehandlung:

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_resilient_session() -> requests.Session:
    """
    Erstellt Session mit automatischen Retries bei Netzwerkproblemen.
    
    Konfiguration:
    - 3 Wiederholungen bei temporären Fehlern
    - Exponential Backoff zwischen Versuchen
    - Timeout: 10 Sekunden
    """
    session = requests.Session()
    
    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504],
        allowed_methods=["GET", "POST"]
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("https://", adapter)
    session.mount("http://", adapter)
    
    return session

def get_market_data_with_fallback(symbol: str = "BTC-USDT") -> dict:
    """
    Ruft Marktdaten mit vollständiger Fehlerbehandlung ab.
    
    Bei primärem Fehler wird ein Cache-Wert zurückgegeben.
    """
    session = create_resilient_session()
    cache = {}  # Einfacher In-Memory-Cache
    
    try:
        response = session.get(
            f"{OKX_BASE_URL}/api/v5/market/ticker?instId={symbol}",
            timeout=10
        )
        response.raise_for_status()
        data = response.json()
        
        if data.get('data'):

Verwandte Ressourcen
Verwandte Artikel