🚀Démarrer avec les API OUPI

Introduction

Les API OUPI sont des interfaces RESTful qui vous permettent d'intégrer la puissance de la plateforme multi-AI OUPI dans vos applications. Avec un accès unifié à GPT, Claude, Mistral et d'autres modèles d'IA, vous pouvez créer des applications intelligentes hébergées en Europe et conformes au RGPD.

🎯 Qu'est-ce que l'API OUPI ?

Caractéristiques principales

Accès multi-modèles IA

GPT-4 (OpenAI)
Claude (Anthropic)
Mistral (AI français)
Interface unifiée pour tous les modèles

Fonctionnalités complètes

🤖 Génération de contenu texte et images
💬 Gestion des conversations (chats)
📝 Plus de 30 templates de génération
📁 Système de documents et favoris
💳 Gestion des abonnements et paiements
🛠️ Support technique intégré

Souveraineté des données

🇪🇺 Hébergement européen
✅ Conformité RGPD
🔒 Sécurité maximale

🔧 Configuration de base

URL de base

https://app.oupi.com/api

Toutes les requêtes API commencent par cette URL.

Authentification

L'API utilise OAuth2 (Laravel Passport) pour l'authentification.

Format de l'en-tête :

Authorization: Bearer {votre_token}

Exemple de requête complète :

GET https://app.oupi.com/api/auth/profile
Authorization: Bearer oupi_abc123xyz456
Content-Type: application/json

Format des réponses

Toutes les réponses sont en JSON.

Codes de statut HTTP :

✅ 200 : Succès
🔐 401 : Non authentifié (token invalide)
🔍 404 : Ressource non trouvée
⚠️ 412 : Échec de la précondition
💰 419 : Plus de crédits disponibles
❌ 500 : Erreur serveur

Exemple de réponse réussie :

{
  "status": "success",
  "data": {
    "id": 123,
    "name": "Jean Dupont",
    "email": "[email protected]"
  }
}

Exemple de réponse d'erreur :

{
  "status": "error",
  "message": "Plus de crédits disponibles",
  "errors": ["Votre solde de crédits est insuffisant"]
}

🔑 Obtenir votre token API

Étape 1 : Prérequis

Avant de commencer, assurez-vous d'avoir :

✅ Un compte OUPI actif sur app.oupi.com
✅ Un abonnement avec des crédits d'API disponibles
✅ Email vérifié

Étape 2 : Accéder aux paramètres API

Via l'interface web :

Connectez-vous à app.oupi.com
Cliquez sur votre profil (coin supérieur droit)
Sélectionnez "Paramètres" ou "Settings"
Naviguez vers la section "API" ou "Développeurs"

Étape 3 : Générer un token

Dans la section API :

Cliquez sur "Générer un nouveau token" ou "Create New Token"
Donnez un nom à votre token (ex: "Production API", "App Mobile")
Cliquez sur "Générer" ou "Generate"

Votre token apparaît :

oupi_abc123def456ghi789jkl012mno345pqr678stu901vwx234yz

⚠️ CRITIQUE : Copiez immédiatement le token !
- Ce token ne sera affiché qu'une seule fois
- Stockez-le dans un gestionnaire de mots de passe
- Ou sauvegardez-le dans un fichier sécurisé

Étape 4 : Sécuriser votre token

🔒 Règles de sécurité essentielles :

❌ NE JAMAIS :

Exposer le token dans le code côté client (JavaScript frontend)
Commiter le token dans Git/GitHub
Partager le token publiquement
L'envoyer par email non chiffré

✅ TOUJOURS :

Utiliser des variables d'environnement
Faire les appels API depuis le backend
Régénérer le token s'il est compromis
Limiter les permissions si possible

Configuration recommandée (.env) :

# .env
OUPI_API_TOKEN=votre_token_ici
OUPI_API_URL=https://app.oupi.com/api

Fichier .gitignore :

.env
.env.local
*.env
node_modules/

🎓 Votre première requête

Test simple : Récupérer votre profil

Endpoint :

GET /api/auth/profile

Description : Récupère les informations de votre profil pour vérifier que l'authentification fonctionne.

Exemple avec cURL

curl -X GET https://app.oupi.com/api/auth/profile \
  -H "Authorization: Bearer VOTRE_TOKEN" \
  -H "Content-Type: application/json"

Réponse attendue :

{
  "id": 123,
  "name": "Jean Dupont",
  "email": "[email protected]",
  "country": "FR",
  "remaining_credits": 5000,
  "plan": "Pro"
}

Exemple JavaScript/Node.js

const fetch = require('node-fetch');

const API_TOKEN = process.env.OUPI_API_TOKEN;
const BASE_URL = 'https://app.oupi.com/api';

async function getProfile() {
  const response = await fetch(`${BASE_URL}/auth/profile`, {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    }
  });

  if (!response.ok) {
    throw new Error(`Erreur HTTP: ${response.status}`);
  }

  const data = await response.json();
  console.log('Profil utilisateur:', data);
  return data;
}

getProfile()
  .then(profile => console.log('✅ Authentification réussie!'))
  .catch(error => console.error('❌ Erreur:', error));

Exemple Python

import os
import requests

API_TOKEN = os.getenv('OUPI_API_TOKEN')
BASE_URL = 'https://app.oupi.com/api'

def get_profile():
    headers = {
        'Authorization': f'Bearer {API_TOKEN}',
        'Content-Type': 'application/json'
    }
    
    response = requests.get(f'{BASE_URL}/auth/profile', headers=headers)
    response.raise_for_status()
    
    data = response.json()
    print('Profil utilisateur:', data)
    return data

if __name__ == '__main__':
    try:
        profile = get_profile()
        print('✅ Authentification réussie!')
    except Exception as error:
        print(f'❌ Erreur: {error}')

Exemple PHP

<?php
$apiToken = getenv('OUPI_API_TOKEN');
$baseUrl = 'https://app.oupi.com/api';

function getProfile($baseUrl, $apiToken) {
    $ch = curl_init("$baseUrl/auth/profile");
    
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        "Authorization: Bearer $apiToken",
        "Content-Type: application/json"
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        throw new Exception("Erreur HTTP: $httpCode");
    }
    
    $data = json_decode($response, true);
    echo "Profil utilisateur: " . print_r($data, true);
    return $data;
}

try {
    $profile = getProfile($baseUrl, $apiToken);
    echo "✅ Authentification réussie!\n";
} catch (Exception $e) {
    echo "❌ Erreur: " . $e->getMessage() . "\n";
}
?>

📊 Vérifier votre utilisation

Endpoint d'utilisation

GET /api/app/usage-data

Description : Récupère vos données d'utilisation, crédits restants et détails de votre plan.

Exemple :

async function checkUsage() {
  const response = await fetch(`${BASE_URL}/app/usage-data`, {
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    }
  });

  const usage = await response.json();
  
  console.log('Crédits restants:', usage.remaining_credits);
  console.log('Plan actuel:', usage.plan_name);
  console.log('Crédits utilisés ce mois:', usage.monthly_usage);
  
  return usage;
}

Réponse type :

{
  "plan_name": "Pro",
  "remaining_credits": 4850,
  "monthly_usage": 1150,
  "total_credits": 6000,
  "reset_date": "2025-01-01"
}

🏗️ Architecture recommandée

Protection de votre token

🛡️ Architecture Backend-Frontend sécurisée :

┌─────────────────┐
│   Frontend      │  (React, Vue, Angular)
│  (Navigateur)   │
└────────┬────────┘
         │ HTTPS
         ↓
┌─────────────────┐
│  Votre Backend  │  (Node.js, Python, PHP)
│  (Serveur)      │  ← Token API stocké ici
└────────┬────────┘
         │ API Token
         ↓
┌─────────────────┐
│   API OUPI      │  (app.oupi.com/api)
└─────────────────┘

Pourquoi cette architecture ?

✅ Le token ne quitte jamais votre backend
✅ Contrôle total sur les requêtes
✅ Sécurité maximale
✅ Possibilité d'ajouter votre logique métier

Exemple d'implémentation :

Backend (Node.js/Express) :

// server.js
const express = require('express');
const app = express();

// Votre endpoint qui appelle OUPI
app.post('/api/generate-content', async (req, res) => {
  try {
    // Appel à l'API OUPI depuis le backend
    const response = await fetch('https://app.oupi.com/api/aiwriter/generate', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.OUPI_API_TOKEN}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(req.body)
    });
    
    const data = await response.json();
    res.json(data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000);

Frontend (React) :

// App.js
async function generateContent(params) {
  // Appel à VOTRE backend (pas directement à OUPI)
  const response = await fetch('https://votreapp.com/api/generate-content', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(params)
  });
  
  return await response.json();
}

⚠️ Gestion des erreurs

Gérer l'erreur "Plus de crédits" (419)

Code de gestion robuste :

async function callOupiAPI(endpoint, options) {
  try {
    const response = await fetch(`${BASE_URL}${endpoint}`, {
      ...options,
      headers: {
        'Authorization': `Bearer ${API_TOKEN}`,
        'Content-Type': 'application/json',
        ...options.headers
      }
    });

    // Gérer les différents codes d'erreur
    if (response.status === 419) {
      const error = await response.json();
      console.error('❌ Plus de crédits:', error.errors);
      return {
        error: 'no_credits',
        message: error.errors[0],
        redirectTo: 'https://app.oupi.com/pricing' // Rediriger vers upgrade
      };
    }

    if (response.status === 401) {
      throw new Error('Token invalide ou expiré');
    }

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Erreur ${response.status}: ${error.message || error.errors}`);
    }

    return await response.json();
  } catch (error) {
    console.error('Erreur API OUPI:', error);
    throw error;
  }
}

Retry avec backoff exponentiel

Pour les erreurs temporaires (500, timeout) :

async function callWithRetry(endpoint, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await callOupiAPI(endpoint, options);
      
      // Ne pas retry pour ces erreurs
      if (response.error === 'no_credits' || response.status === 401) {
        return response;
      }
      
      return response;
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      
      // Attendre avant de réessayer (backoff exponentiel)
      const waitTime = 1000 * Math.pow(2, i); // 1s, 2s, 4s...
      console.log(`Retry ${i + 1}/${maxRetries} dans ${waitTime}ms...`);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
  }
}

📚 Fonctionnalités disponibles

Vue d'ensemble des endpoints

Chat AI (Conversations)

Créer et gérer des conversations
Envoyer des messages avec streaming
Historique et gestion des chats

AI Writer (Génération de contenu)

30+ templates de génération
Articles, emails, descriptions produits
Code, résumés, traductions

Génération d'images

DALL-E et Stable Diffusion
Création d'images personnalisées

Gestion des documents

Stockage et organisation
Recherche et filtres
Export multi-formats

Brand Voice

Personnalisation du ton
Cohérence de marque

Abonnements et paiements

Gestion programmatique
Suivi de la consommation

✅ Checklist de démarrage

Avant de passer à la production :

[ ] Token API généré et stocké en sécurité
[ ] Variables d'environnement configurées
[ ] Premier appel API réussi (profil)
[ ] Vérification de l'utilisation fonctionnelle
[ ] Architecture backend mise en place
[ ] Gestion d'erreurs implémentée
[ ] Retry avec backoff configuré
[ ] Logging des erreurs en place
[ ] Tests de tous les endpoints nécessaires
[ ] Documentation interne créée

🚀 Prochaines étapes

Maintenant que vous avez les bases, explorez nos guides détaillés :

Guide Chat AI : Créer des conversations intelligentes
Guide AI Writer : Générer du contenu avec les templates
Guide Images AI : Créer des visuels avec DALL-E
Guide Documents : Gérer vos contenus générés
Guide avancé : Optimisation et production

Bienvenue dans l'écosystème API OUPI ! 🎉

Dernière mise à jour : Décembre 2024
Guide de démarrage - API OUPI v1.0