Passer au contenu principal

​
Intégration rapide

Connexion en un clic à plus de 30 fournisseurs de services IA majeurs Migration sans code · Routage intelligent · Optimisation des coûts

​
Concept fondamental

EvoLink adopte une architecture de tâches asynchrones, tous les services IA sont traités comme des tâches :

Soumettre une tâche

Envoyez une requête, obtenez immédiatement un identifiant de tâche

Suivi en temps réel

Consultez la progression, recevez des mises à jour de statut

Obtenir les résultats

Récupérez les résultats finaux une fois la tâche terminée

​
Prérequis

​
Obtenir une clé API

1

Créer un compte

Rendez-vous sur la Console EvoLink pour finaliser votre inscription
2

Créer une clé

Accédez à la page de gestion des API, cliquez sur « Nouvelle clé »
3

Sauvegarder la clé

Copiez la clé API générée (format : sk-evo-xxxxxxxxxx)
La clé API dispose de toutes les permissions du compte, veuillez la conserver en lieu sûr. En cas de fuite, réinitialisez-la immédiatement.

​
Expérience en 30 secondes

​
Exemple de génération d’image

# Soumettre une tâche de génération d'image
curl -X POST https://api.evolink.ai/v1/images/generations \\
  -H "Authorization: Bearer YOUR_API_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "gpt-4o-image",
    "prompt": "A cute cat running on the grass at sunset with warm lighting"
  }'
Réponse immédiate - Tâche créée 
{
  "created": 1757156493,
  "id": "task-unified-1757156493-imcg5zqt",
  "model": "gpt-4o-image",
  "object": "image.generation.task",
  "progress": 0,
  "status": "pending",
  "task_info": {
    "can_cancel": true,
    "estimated_time": 100
  },
  "type": "image",
  "usage": {
    "billing_rule": "per_call",
    "credits_reserved": 252,
    "estimated_cost": 0.252,
    "user_group": "default"
  }
}

​
Consulter le statut de la tâche

# Utiliser l'identifiant de tâche retourné pour consulter le statut
curl https://api.evolink.ai/v1/tasks/task-unified-1757156493-imcg5zqt \\
  -H "Authorization: Bearer YOUR_API_KEY"
Réponse après achèvement de la tâche 
{
  "created": 1757156493,
  "id": "task-unified-1757156493-imcg5zqt",
  "model": "gpt-4o-image",
  "object": "image.generation.task",
  "progress": 100,
  "results": [
    "https://tempfile.aiquickdraw.com/s/generated_image_url.png"
  ],
  "status": "completed",
  "task_info": {
    "can_cancel": false
  },
  "type": "image"
}

​
Capacités IA multimodales

​
🎨 Génération d’images

import requests

# Génération d'image GPT-4O
response = requests.post(
    "https://api.evolink.ai/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "gpt-4o-image",
        "prompt": "A beautiful sunset over the ocean with vibrant colors",
        "size": "1024x1024",
        "n": 1
    }
)

task = response.json()
print(f"Task ID: {task['id']}")
print(f"Temps estimé : {task['task_info']['estimated_time']} secondes")

​
🎬 Génération de vidéos

import requests
import time

# Génération de vidéo Veo3-Fast
def generate_video():
    # Soumettre une tâche de génération de vidéo
    response = requests.post(
        "https://api.evolink.ai/v1/videos/generations",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "veo3-fast",
            "prompt": "A cat chasing butterflies in the garden, slow motion",
            "aspect_ratio": "16:9"
        }
    )

    task = response.json()
    task_id = task['id']

    print(f"Tâche vidéo créée : {task_id}")
    print(f"Temps d'achèvement estimé : {task['task_info']['estimated_time']} secondes")
    print(f"Coût estimé : ${task['usage']['estimated_cost']}")

    return task_id

# Surveiller la progression de la tâche
def monitor_task(task_id):
    while True:
        response = requests.get(
            f"https://api.evolink.ai/v1/tasks/{task_id}",
            headers={"Authorization": "Bearer YOUR_API_KEY"}
        )

        task = response.json()
        status = task['status']
        progress = task['progress']

        print(f"Statut : {status}, Progression : {progress}%")

        if status == "completed":
            return task['results'][0]  # URL de la vidéo dans le tableau results
        elif status == "failed":
            raise Exception(f"Tâche échouée : {task.get('error')}")

        time.sleep(10)  # Interroger toutes les 10 secondes

# Exemple d'utilisation
task_id = generate_video()
video_url = monitor_task(task_id)
print(f"Génération vidéo terminée : {video_url}")

​
Intégration rapide avec SDK

​
Python SDK

import openai
import requests

class EvoLinkClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.evolink.ai"
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def create_image(self, model, prompt, **kwargs):
        """Créer une tâche de génération d'image"""
        response = requests.post(
            f"{self.base_url}/v1/images/generations",
            headers=self.headers,
            json={"model": model, "prompt": prompt, **kwargs}
        )
        return response.json()

    def create_video(self, model, prompt, **kwargs):
        """Créer une tâche de génération de vidéo"""
        response = requests.post(
            f"{self.base_url}/v1/videos/generations",
            headers=self.headers,
            json={"model": model, "prompt": prompt, **kwargs}
        )
        return response.json()

    def get_task(self, task_id):
        """Obtenir le statut de la tâche"""
        response = requests.get(
            f"{self.base_url}/v1/tasks/{task_id}",
            headers=self.headers
        )
        return response.json()

    def wait_for_completion(self, task_id, timeout=300):
        """Attendre l'achèvement de la tâche"""
        import time
        start_time = time.time()

        while time.time() - start_time < timeout:
            task = self.get_task(task_id)

            if task['status'] == 'completed':
                return task
            elif task['status'] == 'failed':
                raise Exception(f"Tâche échouée : {task.get('error')}")

            time.sleep(5)

        raise TimeoutError("Délai d'exécution de la tâche dépassé")

# Exemple d'utilisation
client = EvoLinkClient("YOUR_API_KEY")

# Générer une image
task = client.create_image(
    model="gpt-4o-image",
    prompt="A modern intelligent office building"
)

result = client.wait_for_completion(task['id'])
print(f"URL de l'image : {result['results'][0]}")

​
JavaScript/Node.js

class EvoLinkClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.evolink.ai';
  }

  async createImage(model, prompt, options = {}) {
    const response = await fetch(`${this.baseURL}/v1/images/generations`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ model, prompt, ...options })
    });

    return response.json();
  }

  async getTask(taskId) {
    const response = await fetch(`${this.baseURL}/v1/tasks/${taskId}`, {
      headers: { 'Authorization': `Bearer ${this.apiKey}` }
    });

    return response.json();
  }

  async waitForCompletion(taskId, timeout = 300000) {
    const startTime = Date.now();

    while (Date.now() - startTime < timeout) {
      const task = await this.getTask(taskId);

      if (task.status === 'completed') {
        return task;
      } else if (task.status === 'failed') {
        throw new Error(`Tâche échouée : ${task.error}`);
      }

      await new Promise(resolve => setTimeout(resolve, 5000));
    }

    throw new Error("Délai d'exécution de la tâche dépassé");
  }
}

// Exemple d'utilisation
async function generateImage() {
  const client = new EvoLinkClient('YOUR_API_KEY');

  try {
    // Créer une tâche
    const task = await client.createImage(
      'doubao-seedream-4.0',
      'An abstract art painting with rich colors'
    );

    console.log('Tâche créée :', task.id);

    // Attendre l'achèvement
    const result = await client.waitForCompletion(task.id);
    console.log('Génération d\'image terminée :', result.results[0]);

  } catch (error) {
    console.error('Échec de la génération :', error.message);
  }
}

generateImage();

​
Bonnes pratiques pour la production

​
Stratégie de gestion des erreurs

import requests
from typing import Optional
import time

class EvoLinkError(Exception):
    """Classe de base des exceptions API EvoLink"""
    pass

class RateLimitError(EvoLinkError):
    """Exception de limite de débit"""
    pass

class QuotaExhaustedError(EvoLinkError):
    """Exception de quota épuisé"""
    pass

def handle_api_call(func, *args, **kwargs):
    """Gestion unifiée des erreurs d'appel API"""
    max_retries = 3
    retry_delay = 1

    for attempt in range(max_retries):
        try:
            response = func(*args, **kwargs)

            if response.status_code == 200:
                return response.json()
            elif response.status_code == 429:
                # Limite de débit, attendre et réessayer
                wait_time = int(response.headers.get('Retry-After', retry_delay))
                print(f"Limite de débit atteinte, attente de {wait_time} secondes avant nouvelle tentative...")
                time.sleep(wait_time)
                retry_delay *= 2
                continue
            elif response.status_code == 402:
                raise QuotaExhaustedError("Solde du compte insuffisant, veuillez recharger")
            else:
                error_data = response.json()
                raise EvoLinkError(f"Échec de l'appel API : {error_data.get('error', {}).get('message')}")

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise EvoLinkError(f"Échec de la requête réseau : {str(e)}")
            time.sleep(retry_delay)
            retry_delay *= 2

    raise EvoLinkError("Nombre maximum de tentatives atteint")

# Exemple d'utilisation
try:
    result = handle_api_call(
        requests.post,
        "https://api.evolink.ai/v1/images/generations",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={"model": "gpt-4o-image", "prompt": "Test image"}
    )
    print("Tâche créée avec succès :", result['id'])
except QuotaExhaustedError:
    print("Veuillez recharger dans la console : https://evolink.ai/dashboard/billing")
except EvoLinkError as e:
    print(f"Exception d'appel API : {e}")

​
Conseils d’optimisation des performances

import asyncio
import aiohttp

async def create_task_async(session, model, prompt):
    """Création de tâche asynchrone"""
    async with session.post(
        "https://api.evolink.ai/v1/images/generations",
        json={"model": model, "prompt": prompt}
    ) as response:
        return await response.json()

async def batch_generate_images(prompts, model="gpt-4o-image"):
    """Génération d'images par lots"""
    headers = {"Authorization": "Bearer YOUR_API_KEY"}

    async with aiohttp.ClientSession(headers=headers) as session:
        # Créer toutes les tâches simultanément
        tasks = [
            create_task_async(session, model, prompt)
            for prompt in prompts
        ]
        results = await asyncio.gather(*tasks)

        # Retourner la liste des identifiants de tâches
        return [result['id'] for result in results]

# Exemple d'utilisation
prompts = [
    "Modern office design",
    "Natural landscape painting",
    "Abstract artwork",
    "Tech-style UI interface"
]

task_ids = asyncio.run(batch_generate_images(prompts))
print(f"{len(task_ids)} tâches créées")

​
Surveillance et analyses

​
Suivi de l’utilisation

Rendez-vous sur la Console EvoLink pour consulter en temps réel :

Surveillance en temps réel

  • Statistiques d’appels API
  • Taux de succès et d’erreurs
  • Analyse des temps de réponse
  • Surveillance des requêtes simultanées

Analyse des coûts

  • Répartition des coûts par modèle
  • Tendances d’utilisation quotidiennes/mensuelles
  • Prévisions et alertes de coûts
  • État d’utilisation des quotas

​
Surveillance personnalisée

import logging
from datetime import datetime

class EvoLinkMonitor:
    def __init__(self):
        # Configurer la journalisation
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('evolink_api.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)

    def log_task_creation(self, task_id, model, cost):
        """Journaliser la création de tâche"""
        self.logger.info(f"Tâche créée | ID:{task_id} | Modèle:{model} | Coût:${cost}")

    def log_task_completion(self, task_id, duration, status):
        """Journaliser l'achèvement de tâche"""
        self.logger.info(f"Tâche terminée | ID:{task_id} | Durée:{duration}s | Statut:{status}")

    def log_error(self, error, context=""):
        """Journaliser les erreurs"""
        self.logger.error(f"Erreur API | {context} | {str(error)}")

# Exemple d'utilisation
monitor = EvoLinkMonitor()

# Utiliser dans les appels API
start_time = time.time()
try:
    task = client.create_image("gpt-4o-image", "Test prompt")
    monitor.log_task_creation(
        task['id'],
        task['model'],
        task['usage']['estimated_cost']
    )

    result = client.wait_for_completion(task['id'])
    duration = time.time() - start_time
    monitor.log_task_completion(task['id'], int(duration), "completed")

except Exception as e:
    monitor.log_error(e, f"Task ID: {task.get('id', 'unknown')}")

​
Résumé des bonnes pratiques

Recommandations de développement

  • Toujours implémenter la gestion des erreurs
  • Utiliser la programmation asynchrone pour plus d’efficacité
  • Définir des valeurs de délai d’attente raisonnables
  • Journaliser les informations détaillées des appels

Optimisation des performances

  • Le traitement par lots réduit la surcharge réseau
  • Utiliser des pools de tâches pour la gestion de la concurrence
  • Surveiller l’utilisation des quotas API
  • Mettre en cache les résultats fréquemment utilisés

Considérations de sécurité

  • Stockage sécurisé des clés API
  • Utiliser des variables d’environnement pour la configuration
  • Effectuer une rotation régulière des clés d’accès
  • Surveiller les comportements d’appel anormaux

Contrôle des coûts

  • Définir des limites budgétaires raisonnables
  • Choisir les modèles appropriés
  • Optimiser la longueur des prompts
  • Surveiller les tendances d’utilisation

​
Prêt à commencer ?

Lancez votre parcours de création IA dès maintenant

Console

Gérer les clés API et surveiller l’utilisation

Documentation API

Consulter la documentation détaillée des interfaces

Gestion des tâches

En savoir plus sur les requêtes de statut des tâches
Besoin d’aide ? Notre équipe technique est toujours prête à vous fournir un support professionnel