Pour de nombreux profils techniques, l'investissement représente un leveir complémentaire aux revenus salariaux. Cependant, naviguer dans les produits financiers comme les plateformes de prêt entre particuliers (P2P) demande plus que de l'intuition : cela nécessite des données précises. Cet article explore comment utiliser Python pour automatiser la collecte et l'analyse de données afin d'optimiser une stratégie d'investissement basée sur le marché secondaire des créances.

Le concept de l'investissement à effet de levier

Sur certaines plateformes de financement participatif, le mécanisme repose sur des règles spécifiques :

• Des produits à durée fixe (12, 24, 36 mois) avec des taux progressifs.
• La possibilité de revendre ses créances à d'autres investisseurs en ajustant le taux de sortie.
• L'utilisation de l'effet de levier (emprunter pour réinvestir jusqu'à 3 fois son capitol).

Le succès de cette stratégie dépend de la capacité à revendre rapidement ses titres pour rembourser les emprunts contractés. Le paramètre critique est le taux d'intérêt de revente : trop élevé, personne n'achète ; trop bas, le profit s'évapore. Pour arbitrer correctement, il est essentiel de suivre en temps réel le volume des transactions et le montant total restant à rembourser sur la plateforme.

Architecture technique

Le système repose sur une stack robuste et simple :

• Python : Pour le scripting et le traitement logique.
• MySQL : Pour le stockage historique des transactions.
• Redis : Pour la mise en cache des indicateurs de performance en temps réel.

Phase 1 : Extraction automatisée des données

La première étape consiste à récupérer les données de transaction. De nombreuses plateformes utilisent des appels AJAX pour charger leurs listes de projets. Nous pouvons intercepter ces requêtes JSON pour extraire les informations brutes.

import requests
import pymysql
import re
import time
from datetime import datetime, timedelta

def collecter_donnees():
    # Configuration de la base de données
    conn = pymysql.connect(host='127.0.0.1', user='invest_user', password='secure_password', db='finance_db')
    curseur = conn.cursor()

    for page in range(1, 500):
        params = {
            "pageindex": page,
            "pagesize": 10,
            "status": 2,
            "orderby": 15
        }
        
        try:
            api_url = "https://api.plateforme-p2p.com/get_market_data"
            reponse = requests.post(api_url, data=params).json()

            if reponse.get('status') == 'success':
                html_fragment = reponse.get('content')
                # Nettoyage des balises pour extraire le texte
                texte_propre = re.sub('<[^>]+>', ' ', html_fragment).split()
                
                # Extraction de l'ID de transaction (basé sur un pattern numérique)
                id_transaction = ''.join(re.findall(r'\d+', texte_propre[0]))

                # Vérification de l'existence du record
                curseur.execute("SELECT id FROM transactions WHERE id = %s", (id_transaction,))
                if curseur.fetchone() is None:
                    # Traitement de la date et du montant
                    date_pub = datetime.now()
                    montant_brut = texte_propre[1].replace('€', '').replace(',', '')
                    taux = texte_propre[4].replace('%', '')
                    
                    # Insertion SQL
                    sql = "INSERT INTO transactions (id, date_creation, montant, taux) VALUES (%s, %s, %s, %s)"
                    curseur.execute(sql, (id_transaction, date_pub, float(montant_brut), float(taux)))
                    conn.commit()
                else:
                    print(f"Transaction {id_transaction} déjà enregistrée.")
                    break # On arrête si on rencontre des données connues

            time.sleep(0.5)
        except Exception as e:
            print(f"Erreur lors du crawl : {e}")
            break

    conn.close()

Phase 2 : Analyse et mise en cache

Une fois les données stockées, il faut calculer des indicateurs clés comme le volume d'échanges horaire et le ratio de liquidité. Ces données sont stockées dans Redis pour un accès instantané par un tableau de bord ou un bot de notification.

import redis
import json
from datetime import date

def generer_statistiques():
    db_conn = pymysql.connect(host='127.0.0.1', user='invest_user', db='finance_db')
    cache = redis.Redis(host='localhost', port=6379, db=0)
    
    aujourdhui = date.today().isoformat()
    curseur = db_conn.cursor()

    try:
        # Calcul du volume total du jour
        curseur.execute("SELECT COUNT(*), SUM(montant) FROM transactions WHERE DATE(date_creation) = %s", (aujourdhui,))
        stats = curseur.fetchone()
        
        nb_transactions = stats[0]
        volume_total = stats[1] if stats[1] else 0

        # Estimation de la vitesse de remboursement
        donnees_cache = {
            "date": aujourdhui,
            "volume_cumule": float(volume_total),
            "nb_ventes": nb_transactions,
            "maj_timestamp": datetime.now().strftime('%H:%M:%S')
        }

        # Stockage dans Redis avec expiration de 2 heures
        cle_redis = f"p2p_stats_{datetime.now().strftime('%Y%m%d')}"
        cache.setex(cle_redis, 7200, json.dumps(donnees_cache))
        print("Statistiques mises à jour avec succès.")

    except Exception as e:
        print(f"Erreur de traitement : {e}")
    finally:
        db_conn.close()

Utilité opérationnelle

Grâce à ce pipeline de données, l'investisseur peut déterminer précisément si le marché est "saturé" ou "liquide" à un instant T. Par exemple, si le volume de transactions enregistrées au cours de la dernière heure est inférieur à la moyenne habituelle, il est préférable d'abaisser légèrement le taux de revente pour garantir une sortie de position rapide et éviter les pénalités de retard sur l'emprunt à effet de levier.

L'automatisation permet ainsi de transformer une activité chronophage de surveillance manuelle en un système d'aide à la décision factuel, augmentant ainsi significativement la rentabilité nette après risque.