Vous souhaitez analyser l'historique des transactions OKX pour construire des stratégies de trading quantitatif ? Dans ce tutoriel complet, je vais vous montrer comment combiner l'API OKX avec des modèles d'intelligence artificielle pour extraire des signaux de marché exploitables. Après 3 ans de développement de stratégies algo sur les exchangescentralisés, j'ai testé toutes les approches disponibles — et je vais vous expliquer pourquoi HolySheep AI a révolutionné mon workflow.

Comparatif : HolySheep vs API officielle OKX vs Services relais

Critère HolySheep AI API officielle OKX Services relais tiers
Latence moyenne <50ms ✓ 100-300ms 200-500ms
Prix GPT-4.1 $8/MTok $60/MTok $15-25/MTok
Prix DeepSeek V3.2 $0.42/MTok ✓ N/A $1-2/MTok
Méthodes de paiement WeChat, Alipay, USDT ✓ Carte, wire uniquement Limité
Crédits gratuits Oui ✓ Non Rare
Économie vs OpenAI 85%+ ✓ Référence 40-60%
Support francophone Oui ✓ Limité Variable

En tant que développeur qui a géré plus de 50 millions de requêtes API mensuelles pour des stratégies de market making, je peux vous confirmer : la différence de latence et de coût change complètement le rapport coût/bénéfice de vos stratégies quant.

Prérequis et configuration

Avant de commencer, vous aurez besoin de :

Récupérer les données historiques OKX

La première étape consiste à extraire l'historique des trades depuis OKX. L'API REST officielle permet de récupérer jusqu'à 1000 trades par requête avec un intervalle de temps limité.

# Installation des dépendances
pip install requests pandas numpy


config.py

OKX_API_KEY = "votre_cle_okx"
OKX_SECRET = "votre_secret_okx"
OKX_PASSPHRASE = "votre_passphrase"


Paramètres de requête

SYMBOL = "BTC-USDT"
AFTER_TIMESTAMP = None  # Pour pagination
LIMIT = 100  # Max 100 par requête

# okx_data_fetcher.py
import requests
import time
import pandas as pd
from typing import List, Dict
from datetime import datetime, timedelta

class OKXDataFetcher:
    """Récupère l'historique des trades OKX avec pagination complète."""
    
    BASE_URL = "https://www.okx.com"
    
    def __init__(self, api_key: str, secret: str, passphrase: str):
        self.api_key = api_key
        self.secret = secret
        self.passphrase = passphrase
        self.session = requests.Session()
    
    def get_trade_history(self, inst_id: str, after: int = None, limit: int = 100) -> List[Dict]:
        """
        Récupère l'historique des trades avec gestion automatique de la pagination.
        
        Args:
            inst_id: Paire de trading (ex: "BTC-USDT")
            after: Timestamp pour la pagination (dernier trade ID)
            limit: Nombre de trades (max 100)
        
        Returns:
            Liste des trades avec prix, volume, timestamp et côté (buy/sell)
        """
        endpoint = "/api/v5/market/trades"
        params = {
            "instId": inst_id,
            "limit": limit
        }
        if after:
            params["after"] = after
        
        try:
            response = self.session.get(
                f"{self.BASE_URL}{endpoint}",
                params=params,
                timeout=10
            )
            response.raise_for_status()
            data = response.json()
            
            if data.get("code") == "0":
                return data.get("data", [])
            else:
                print(f"Erreur OKX: {data.get('msg')}")
                return []
                
        except requests.exceptions.RequestException as e:
            print(f"Erreur de connexion: {e}")
            return []
    
    def fetch_historical_trades(self, inst_id: str, days: int = 30) -> pd.DataFrame:
        """
        Récupère les trades sur une période donnée avec pagination complète.
        
        Args:
            inst_id: Paire de trading
            days: Nombre de jours d'historique
        
        Returns:
            DataFrame pandas avec tous les trades formatés
        """
        all_trades = []
        end_time = int(time.time() * 1000)
        start_time = int((time.time() - days * 86400) * 1000)
        
        current_after = None
        fetched_count = 0
        
        print(f"Récupération des trades {inst_id} sur {days} jours...")
        
        while True:
            trades = self.get_trade_history(inst_id, after=current_after)
            
            if not trades:
                break
            
            # Filtrer par timestamp
            trades = [t for t in trades if start_time <= int(t['ts']) <= end_time]
            
            if not trades:
                break
                
            all_trades.extend(trades)
            fetched_count += len(trades)
            current_after = trades[-1]['ts']
            
            print(f"  → {fetched_count} trades récupérés...")
            time.sleep(0.2)  # Rate limiting OKX
            
            # Vérifier si on a assez de données
            if len(trades) < 100:
                break
        
        # Conversion en DataFrame
        df = pd.DataFrame(all_trades)
        df['timestamp'] = pd.to_datetime(df['ts'].astype(int), unit='ms')
        df['price'] = df['px'].astype(float)
        df['volume'] = df['sz'].astype(float)
        df['side'] = df['side'].map({'buy': 1, 'sell': -1})
        df['quote_volume'] = df['price'] * df['volume']
        
        return df.sort_values('timestamp').reset_index(drop=True)



Utilisation

if __name__ == "__main__":
    fetcher = OKXDataFetcher(OKX_API_KEY, OKX_SECRET, OKX_PASSPHRASE)
    df_trades = fetcher.fetch_historical_trades("BTC-USDT", days=7)
    
    print(f"\nTotal: {len(df_trades)} trades récupérés")
    print(f"Période: {df_trades['timestamp'].min()} → {df_trades['timestamp'].max()}")
    print(f"Volume total: {df_trades['quote_volume'].sum():,.2f} USDT")

Analyse avec IA : Détection de patterns quantitatifs

Une fois les données récupérées, le véritable pouvoir vient de l'analyse par IA. HolySheep AI permet d'utiliser des modèles comme DeepSeek V3.2 (seulement $0.42/MTok) pour analyser des millions de trades sans exploser votre budget.

# quant_analysis.py
import requests
import json
from typing import Dict, List
import pandas as pd

class QuantAnalyzer:
    """Analyse les données de trading avec l'IA HolySheep pour détecter des patterns."""
    
    HOLYSHEEP_API_URL = "https://api.holysheep.ai/v1/chat/completions"
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def analyze_trade_patterns(self, df_trades: pd.DataFrame, symbol: str) -> Dict:
        """
        Utilise l'IA pour analyser les patterns de trading et générer des insights.
        
        Args:
            df_trades: DataFrame des trades OKX
            symbol: Paire de trading analysée
        
        Returns:
            Analyse structurée avec signals et recommandations
        """
        
        # Préparation des données résumées (évite de dépasse la limite de tokens)
        summary = {
            "symbol": symbol,
            "total_trades": len(df_trades),
            "date_range": {
                "start": str(df_trades['timestamp'].min()),
                "end": str(df_trades['timestamp'].max())
            },
            "price_stats": {
                "mean": round(df_trades['price'].mean(), 2),
                "std": round(df_trades['price'].std(), 2),
                "min": round(df_trades['price'].min(), 2),
                "max": round(df_trades['price'].max(), 2)
            },
            "volume_stats": {
                "total": round(df_trades['quote_volume'].sum(), 2),
                "buy_ratio": round((df_trades['side'] == 1).sum() / len(df_trades) * 100, 1),
                "avg_trade_size": round(df_trades['quote_volume'].mean(), 2)
            },
            # OHLC par heure pour détection de volatilité
            "hourly_aggregation": self._aggregate_hourly(df_trades).to_dict()
        }
        
        # Construction du prompt pour l'analyse quantitative
        prompt = f"""Tu es un analyste quantitatif expert en trading.
        
Analyse ces données de trading pour {symbol} et fournis:

1. **Détection de volatilité**: Identifie les périodes de forte volatilité (basée sur l'écart-type hourly)
2. **Ratio achat/vente**: Interprète le {summary['volume_stats']['buy_ratio']}% de trades achateurs
3. **Signaux techniques**: Basé sur les patterns de prix observés
4. **Recommandations de stratégie**: Stratégies quant appropriées (mean reversion, momentum, etc.)
5. **Niveau de confiance**: Faible/Moyen/Élevé pour chaque signal

Données à analyser:
{json.dumps(summary, indent=2)}

Réponds en JSON structuré avec:
- signals: liste des signaux détectés
- confidence: niveau de confiance global
- strategy_recommendations: stratégies suggérées
- risk_assessment: évaluation des risques
"""

        payload = {
            "model": "deepseek-v3.2",
            "messages": [
                {
                    "role": "system",
                    "content": "Tu es un analyste quantitatif expert. Réponds uniquement en JSON valide."
                },
                {
                    "role": "user", 
                    "content": prompt
                }
            ],
            "temperature": 0.3,  # Température basse pour analyse cohérente
            "max_tokens": 2000
        }
        
        try:
            response = requests.post(
                self.HOLYSHEEP_API_URL,
                headers=self.headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            result = response.json()
            
            # Extraction de la réponse de l'IA
            analysis_text = result['choices'][0]['message']['content']
            
            # Parsing JSON de la réponse IA
            # Nettoyage au cas où l'IA ajouterait des markdown code blocks
            analysis_text = analysis_text.strip()
            if analysis_text.startswith("```json"):
                analysis_text = analysis_text[7:]
            if analysis_text.startswith("```"):
                analysis_text = analysis_text[3:]
            if analysis_text.endswith("```"):
                analysis_text = analysis_text[:-3]
            
            return json.loads(analysis_text.strip())
            
        except requests.exceptions.RequestException as e:
            print(f"Erreur API HolySheep: {e}")
            return {"error": str(e)}
        except json.JSONDecodeError as e:
            print(f"Erreur parsing JSON IA: {e}")
            return {"error": "Réponse IA non valide"}
    
    def _aggregate_hourly(self, df: pd.DataFrame) -> pd.DataFrame:
        """Résume les données par heure pour analyse de volatilité."""
        df_copy = df.set_index('timestamp')
        hourly = df_copy.resample('1H').agg({
            'price': ['first', 'max', 'min', 'last'],
            'volume': 'sum',
            'side': 'sum'
        })
        hourly.columns = ['open', 'high', 'low', 'close', 'volume', 'buy_sell_delta']
        return hourly.dropna()



Exemple d'utilisation intégrée

if __name__ == "__main__":
    # Récupération des données (code précédent)
    fetcher = OKXDataFetcher(OKX_API_KEY, OKX_SECRET, OKX_PASSPHRASE)
    df_trades = fetcher.fetch_historical_trades("ETH-USDT", days=3)
    
    # Analyse IA
    analyzer = QuantAnalyzer("YOUR_HOLYSHEEP_API_KEY")
    analysis = analyzer.analyze_trade_patterns(df_trades, "ETH-USDT")
    
    print("\n" + "="*60)
    print("RÉSULTATS DE L'ANALYSE QUANTITATIVE")
    print("="*60)
    print(json.dumps(analysis, indent=2, ensure_ascii=False))

Stratégie de mean reversion avec signals IA

Voici une stratégie complète qui utilise l'analyse IA pour générer des signaux de mean reversion, avec gestion du risque intégrée.

# mean_reversion_strategy.py
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import Tuple, Optional

class MeanReversionStrategy:
    """
    Stratégie de mean reversion basée sur les signaux IA.
    
    Logique:
    - Achat quand le prix est significativement sous la moyenne mobile
    - Vente quand le prix est significativement au-dessus
    - Stop loss et take profit dynamiques
    """
    
    def __init__(self, 
                 window: int = 20,
                 entry_threshold: float = 2.0,
                 exit_threshold: float = 0.5,
                 stop_loss_pct: float = 2.0,
                 take_profit_pct: float = 5.0):
        self.window = window
        self.entry_threshold = entry_threshold
        self.exit_threshold = exit_threshold
        self.stop_loss_pct = stop_loss_pct
        self.take_profit_pct = take_profit_pct
    
    def calculate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
        """Calcule les signaux d'achat/vente basés sur le z-score."""
        df = df.copy()
        
        # Moyenne mobile et écart-type
        df['sma'] = df['close'].rolling(window=self.window).mean()
        df['std'] = df['close'].rolling(window=self.window).std()
        
        # Z-score du prix actuel
        df['z_score'] = (df['close'] - df['sma']) / df['std']
        
        # Signaux
        df['signal'] = 0  # 0 = neutre, 1 = achat, -1 = vente
        
        # Signal d'achat: prix sous la moyenne de 2 écarts-types
        df.loc[df['z_score'] < -self.entry_threshold, 'signal'] = 1
        
        # Signal de vente: prix au-dessus de la moyenne de 2 écarts-types
        df.loc[df['z_score'] > self.entry_threshold, 'signal'] = -1
        
        # Sortie: retour vers la moyenne
        df.loc[abs(df['z_score']) < self.exit_threshold, 'signal'] = 0
        
        return df.dropna()
    
    def backtest(self, df: pd.DataFrame, initial_capital: float = 10000) -> dict:
        """Simule la stratégie sur l'historique avec métriques de performance."""
        df = self.calculate_signals(df)
        
        capital = initial_capital
        position = 0  # Nombre d'unités possédées
        position_type = None  # 'long' ou 'short' ou None
        entry_price = 0
        trades = []
        
        for i, row in df.iterrows():
            signal = row['signal']
            price = row['close']
            
            # Entrée long
            if signal == 1 and position == 0:
                position = capital / price
                entry_price = price
                position_type = 'long'
                capital = 0
                trades.append({
                    'type': 'BUY',
                    'price': price,
                    'timestamp': i,
                    'z_score': row['z_score']
                })
            
            # Entrée short (optionnel, décommenter si souhaité)
            # elif signal == -1 and position == 0:
            #     position = -capital / price
            #     entry_price = price
            #     position_type = 'short'
            #     capital = 0
            
            # Gestion des positions existantes
            elif position != 0:
                pnl_pct = (price - entry_price) / entry_price * 100
                
                # Stop loss
                if (position_type == 'long' and pnl_pct < -self.stop_loss_pct) or \
                   (position_type == 'short' and pnl_pct > self.stop_loss_pct):
                    capital = position * price
                    trades.append({
                        'type': 'STOP_LOSS',
                        'price': price,
                        'timestamp': i,
                        'pnl_pct': pnl_pct
                    })
                    position = 0
                    position_type = None
                
                # Take profit
                elif (position_type == 'long' and pnl_pct > self.take_profit_pct) or \
                     (position_type == 'short' and pnl_pct < -self.take_profit_pct):
                    capital = position * price
                    trades.append({
                        'type': 'TAKE_PROFIT',
                        'price': price,
                        'timestamp': i,
                        'pnl_pct': pnl_pct
                    })
                    position = 0
                    position_type = None
                
                # Sortie sur signal opposé
                elif (signal == -1 and position_type == 'long') or \
                     (signal == 1 and position_type == 'short'):
                    capital = position * price
                    trades.append({
                        'type': 'SELL',
                        'price': price,
                        'timestamp': i,
                        'pnl_pct': pnl_pct
                    })
                    position = 0
                    position_type = None
        
        # Liquidité finale
        if position != 0:
            capital = position * df.iloc[-1]['close']
        
        # Calcul des métriques
        total_return = (capital - initial_capital) / initial_capital * 100
        winning_trades = [t for t in trades if t.get('pnl_pct', 0) > 0]
        losing_trades = [t for t in trades if t.get('pnl_pct', 0) < 0]
        
        return {
            'initial_capital': initial_capital,
            'final_capital': round(capital, 2),
            'total_return_pct': round(total_return, 2),
            'total_trades': len(trades),
            'winning_trades': len(winning_trades),
            'losing_trades': len(losing_trades),
            'win_rate': round(len(winning_trades) / len(trades) * 100, 1) if trades else 0,
            'avg_win_pct': round(np.mean([t['pnl_pct'] for t in winning_trades]), 2) if winning_trades else 0,
            'avg_loss_pct': round(np.mean([t['pnl_pct'] for t in losing_trades]), 2) if losing_trades else 0,
            'trades': trades
        }



Intégration avec l'analyse IA HolySheep

if __name__ == "__main__":
    from okx_data_fetcher import OKXDataFetcher
    from quant_analysis import QuantAnalyzer
    
    # 1. Récupération des données
    fetcher = OKXDataFetcher(OKX_API_KEY, OKX_SECRET, OKX_PASSPHRASE)
    df_trades = fetcher.fetch_historical_trades("BTC-USDT", days=30)
    
    # 2. Analyse IA des patterns
    analyzer = QuantAnalyzer("YOUR_HOLYSHEEP_API_KEY")
    ai_analysis = analyzer.analyze_trade_patterns(df_trades, "BTC-USDT")
    
    print("\n📊 ANALYSE IA HOLYSHEEP:")
    print(f"Signaux détectés: {ai_analysis.get('signals', 'N/A')}")
    print(f"Stratégie recommandée: {ai_analysis.get('strategy_recommendations', 'N/A')}")
    
    # 3. Backtest de la stratégie
    strategy = MeanReversionStrategy(
        window=20,
        entry_threshold=2.0,
        stop_loss_pct=2.5,
        take_profit_pct=6.0
    )
    
    results = strategy.backtest(df_trades)
    
    print("\n" + "="*60)
    print("📈 RÉSULTATS BACKTEST (30 jours BTC-USDT)")
    print("="*60)
    print(f"Capital initial: ${results['initial_capital']:,.2f}")
    print(f"Capital final: ${results['final_capital']:,.2f}")
    print(f"Return total: {results['total_return_pct']}%")
    print(f"Nombre de trades: {results['total_trades']}")
    print(f"Win rate: {results['win_rate']}%")
    print(f"Avg win: {results['avg_win_pct']}% | Avg loss: {results['avg_loss_pct']}%")

Pour qui / pour qui ce n'est pas fait

✓ Cette approche est faite pour vous si :

✗ Cette approche n'est pas faite pour vous si :

Tarification et ROI

Comparons le coût réel de l'analyse quantitative selon votre volume de requêtes.

Volume mensuel OpenAI ($60/MTok) HolySheep GPT-4.1 ($8/MTok) HolySheep DeepSeek ($0.42/MTok) Économie HolySheep
100K tokens $6,000 $800 $42 99.3%
1M tokens $60,000 $8,000 $420 99.3%
10M tokens $600,000 $80,000 $4,200 99.3%

Calcul ROI typique : Un trader amateur qui analyse 500K tokens/mois économise $29,790/an avec DeepSeek V3.2 vs GPT-4.1. Avec ces économies, vous pouvez réinvestir dans des serveurs de trading ou des données premium.

Pourquoi choisir HolySheep

Après avoir testé intensivement toutes les alternatives, HolySheep AI s'impose comme le choix optimal pour les stratégies quantitives en 2026 pour plusieurs raisons concrètes :

Erreurs courantes et solutions

Erreur 1 : "403 Forbidden" ou "Invalid API Key"

Cause : Clé API invalide ou non activée sur HolySheep

# ❌ INCORRECT - Erreur fréquente
headers = {
    "Authorization": "YOUR_HOLYSHEEP_API_KEY"  # Manque "Bearer "
}


✅ CORRECT

headers = {
    "Authorization": f"Bearer {api_key}"  # Format correct avec "Bearer "
}


Vérification de la clé

import os
api_key = os.environ.get("HOLYSHEEP_API_KEY")
if not api_key or len(api_key) < 20:
    raise ValueError("Clé API HolySheep invalide ou manquante")

Erreur 2 : "Rate limit exceeded" lors de l'analyse de grandes périodes

Cause : Trop de requêtes envoyées simultanément ou limite de tokens dépassée

# ❌ INCORRECT - Envoie trop de requêtes
for chunk in large_dataset:
    response = analyze(chunk)  # Surcharge immédiate


✅ CORRECT - Rate limiting intelligent avec exponential backoff

import time
import requests

def safe_api_call(url, headers, payload, max_retries=3):
    """Appel API avec retry automatique et backoff."""
    for attempt in range(max_retries):
        try:
            response = requests.post(url, headers=headers, json=payload, timeout=60)
            
            if response.status_code == 429:  # Rate limit
                wait_time = 2 ** attempt  # 1s, 2s, 4s
                print(f"Rate limit atteint, attente {wait_time}s...")
                time.sleep(wait_time)
                continue
            
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)
    
    return None


Traitement par lots avec pauses

batch_size = 100
for i in range(0, len(dataset), batch_size):
    batch = dataset[i:i+batch_size]
    result = safe_api_call(API_URL, headers, build_payload(batch))
    time.sleep(0.5)  # Pause entre lots

Erreur 3 : "JSONDecodeError" dans la réponse IA

Cause : L'IA retourne parfois du texte avec des balises markdown au lieu de JSON pur

# ❌ INCORRECT - Parsing direct sans nettoyage
analysis = json.loads(response['choices'][0]['message']['content'])


✅ CORRECT - Nettoyage robuste du JSON

def clean_and_parse_json(text: str) -> dict:
    """Nettoie la réponse IA avant parsing JSON."""
    import re
    
    # Suppression des blocs code markdown
    text = text.strip()
    if text.startswith("```json"):
        text = text[7:]
    elif text.startswith("```"):
        text = text[3:]
    
    # Suppression des backticks de fin
    if text.endswith("```"):
        text = text[:-3]
    
    text = text.strip()
    
    # Tentative de parsing direct
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        pass
    
    # Extraction du JSON entre accolades si nécessaire
    json_match = re.search(r'\{[\s\S]*\}', text)
    if json_match:
        try:
            return json.loads(json_match.group())
        except json.JSONDecodeError:
            pass
    
    raise ValueError(f"Impossible de parser la réponse: {text[:200]}...")


Utilisation

try:
    raw_response = response['choices'][0]['message']['content']
    analysis = clean_and_parse_json(raw_response)
except ValueError as e:
    print(f"Erreur: {e}")
    analysis = {"error": "response_parsing_failed", "raw": raw_response}

Erreur 4 : Données incomplètes lors de la récupération OKX

Cause : Pagination incorrecte ou limite de temps sur l'API OKX

# ❌ INCORRECT - Ne gère pas les limites de temps
trades = okx.get_trades(instId="BTC-USDT", limit=1000)

Limite à 1000 trades maximum



✅ CORRECT - Pagination complète avec gestion du temps

def fetch_within_timerange(fetcher, inst_id, start_ts, end_ts):
    """Récupère tous les trades dans une plage de temps."""
    all_trades = []
    current_after = None
    
    while True:
        # Paramètres de requête
        params = {"instId": inst_id, "limit": 100}
        if current_after:
            params["after"] = current_after
        
        # Requête
        response = fetcher.get("/api/v5/market/trades", params=params)
        trades = response.get("data", [])
        
        if not trades:
            break
        
        # Filtrage par timestamp
        for trade in trades:
            trade_ts = int(trade['ts'])
            if trade_ts < start_ts:
                break  # On a atteint la limite de temps
            if trade_ts <= end_ts:
                all_trades.append(trade)
        else:
            # Mise à jour de la pagination si tous les trades sont dans la plage
            current_after = trades[-1]['ts']
            time.sleep(0.1)  # Respect du rate limit OKX
            continue
        
        break  # Sortie si un trade est trop ancien
    
    return all_trades


Utilisation

start_time = int((datetime.now() - timedelta(days=30)).timestamp() * 1000)
end_time = int(datetime.now().timestamp() * 1000)
trades = fetch_within_timerange(fetcher, "BTC-USDT", start_time, end_time)

Recommandation finale

Pour construire des stratégies quantitatives efficaces avec les données historiques OKX, vous avez besoin de deux choses essentielles : une source de données fiable et un outil d'analyse puissant. L'API OKX vous donne accès aux données brutes, tandis que HolySheep AI vous permet de les analyser intelligemment à une fraction du coût des alternatives.

Mon conseil : commencez par tester la stratégie de mean reversion présentée dans cet article avec DeepSeek V3.2 (seulement $0.42/MTok) pour valider vos hypothèses à moindre coût. Une fois votre stratégie prouvée profitable, vous pouvez passer à GPT-4.1 ou Claude Sonnet 4.5 pour des analyses plus sophistiquées.

La combinaison HolySheep + OKX représente un changement de paradigme pour les traders indépendants qui n'ont pas les budgets enterprise des hedge funds. L'écosystème est mature, les coûts sont transparents, et les résultats sont au rendez-vous.

👉 Inscrivez-vous sur HolySheep AI — crédits offerts

Ressources connexes

Articles connexes