> ## Documentation Index
> Fetch the complete documentation index at: https://docs.evolink.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Intégration rapide

> Utiliser EvoLink pour appeler rapidement des modèles d'image, de vidéo et de texte

# Intégration rapide

Ce guide vous aide à effectuer votre premier appel EvoLink en quelques minutes. Les charges multimodales utilisent des tâches asynchrones ; les modèles de texte utilisent une API messages synchrone adaptée au chat et aux outils de codage.

<CardGroup cols={3}>
  <Card title="Génération d'images" icon="image" href="/fr/api-manual/image-series/gpt-image-2/gpt-image-2-image-generation">
    Créez une tâche de génération d'image avec GPT Image 2 et consultez le résultat via l'API de tâches.
  </Card>

  <Card title="Génération vidéo" icon="video" href="/fr/api-manual/video-series/seedance2.0/seedance-2.0-overview">
    Créez des tâches texte-vers-vidéo, image-vers-vidéo et référence-vers-vidéo avec Seedance 2.0.
  </Card>

  <Card title="Génération de texte" icon="comments" href="/fr/api-manual/language-series/claude/claude-messages-api">
    Utilisez l'API Claude Messages pour recevoir des réponses texte synchrones.
  </Card>
</CardGroup>

## Prérequis

<Steps>
  <Step title="Créer une API Key">
    Ouvrez le [tableau de bord EvoLink](https://evolink.ai/dashboard/keys), créez une API Key et stockez-la en sécurité.
  </Step>

  <Step title="Choisir une Base URL">
    Utilisez `https://api.evolink.ai` pour les tâches image, vidéo, audio et autres tâches multimodales. Utilisez `https://direct.evolink.ai` pour les modèles de texte.
  </Step>

  <Step title="Envoyer une requête">
    Les API multimodales retournent d'abord un ID de tâche. Les API texte retournent directement la réponse du modèle.
  </Step>
</Steps>

<Warning>
  Les API Keys peuvent appeler les ressources de votre compte. Stockez-les uniquement côté serveur ou dans des variables d'environnement sécurisées. Ne placez pas de clés dans le code frontend, les dépôts publics ou les paquets client.
</Warning>

## Flux de requête

Les tâches multimodales suivent le même flux :

<CardGroup cols={3}>
  <Card title="1. Soumettre la tâche" icon="paper-plane">
    Appelez un endpoint image, vidéo ou audio et recevez l'ID de tâche dans le champ `id` de la réponse.
  </Card>

  <Card title="2. Consulter le statut" icon="chart-line">
    Utilisez `GET /v1/tasks/{task_id}` pour vérifier `pending`, `processing`, `completed` ou `failed`.
  </Card>

  <Card title="3. Obtenir les résultats" icon="download">
    Quand la tâche est terminée, lisez l'URL du fichier généré dans le champ `results`.
  </Card>
</CardGroup>

<Note>
  Les URL d'images et de vidéos générées expirent généralement. En production, téléchargez et stockez les résultats terminés dans votre propre stockage dès que possible.
</Note>

## Génération d'images

Créez une tâche de génération d'image avec GPT Image 2 :

```bash theme={null}
curl -X POST https://api.evolink.ai/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2",
    "prompt": "Un plan grand angle cinématographique d'une skyline futuriste au crépuscule",
    "size": "16:9",
    "resolution": "4K",
    "quality": "high",
    "n": 1
  }'
```

La réponse retourne un objet de tâche :

```json theme={null}
{
  "id": "task-unified-1757156493-imcg5zqt",
  "object": "image.generation.task",
  "model": "gpt-image-2",
  "status": "pending",
  "progress": 0,
  "task_info": {
    "can_cancel": true,
    "estimated_time": 100
  }
}
```

Consultez le statut de la tâche :

```bash theme={null}
curl https://api.evolink.ai/v1/tasks/task-unified-1757156493-imcg5zqt \
  -H "Authorization: Bearer YOUR_API_KEY"
```

Une fois la tâche terminée, les résultats apparaissent dans le tableau `results` :

```json theme={null}
{
  "id": "task-unified-1757156493-imcg5zqt",
  "object": "image.generation.task",
  "model": "gpt-image-2",
  "status": "completed",
  "progress": 100,
  "results": [
    "https://example.com/generated-image.png"
  ]
}
```

## Génération vidéo

Créez une tâche texte-vers-vidéo avec Seedance 2.0 :

```bash theme={null}
curl -X POST https://api.evolink.ai/v1/videos/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-text-to-video",
    "prompt": "Un plan macro se concentre sur une grenouille de verre verte sur une feuille, puis glisse vers son abdomen transparent où un coeur rouge bat régulièrement.",
    "duration": 8,
    "quality": "720p",
    "aspect_ratio": "16:9",
    "generate_audio": true
  }'
```

Les tâches vidéo se consultent via la même API de tâches :

```bash theme={null}
curl https://api.evolink.ai/v1/tasks/YOUR_VIDEO_TASK_ID \
  -H "Authorization: Bearer YOUR_API_KEY"
```

<Tip>
  Pour l'image-vers-vidéo ou la génération vidéo multi-références, commencez par le [guide complet des paramètres Seedance 2.0](/fr/api-manual/video-series/seedance2.0/seedance-2.0-overview).
</Tip>

## Génération de texte

Les modèles texte Claude doivent utiliser `https://direct.evolink.ai` avec l'endpoint `/v1/messages` :

```bash theme={null}
curl -X POST https://direct.evolink.ai/v1/messages \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-20250929",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Présente EvoLink en trois phrases"
      }
    ]
  }'
```

L'API texte retourne un objet message de manière synchrone :

```json theme={null}
{
  "id": "msg_xxx",
  "type": "message",
  "role": "assistant",
  "model": "claude-sonnet-4-5-20250929",
  "content": [
    {
      "type": "text",
      "text": "EvoLink fournit une passerelle unifiée de services IA..."
    }
  ],
  "stop_reason": "end_turn"
}
```

## Exemple Python

Cet exemple soumet une tâche d'image, interroge son statut et lit le résultat final :

```python theme={null}
import os
import time
import requests

API_KEY = os.environ["EVOLINK_API_KEY"]
BASE_URL = "https://api.evolink.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}


def create_image_task(prompt: str) -> str:
    response = requests.post(
        f"{BASE_URL}/v1/images/generations",
        headers=headers,
        json={
            "model": "gpt-image-2",
            "prompt": prompt,
            "size": "1:1",
            "quality": "high",
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json()["id"]


def wait_for_task(task_id: str, timeout_seconds: int = 300):
    started_at = time.time()

    while time.time() - started_at < timeout_seconds:
        response = requests.get(
            f"{BASE_URL}/v1/tasks/{task_id}",
            headers={"Authorization": f"Bearer {API_KEY}"},
            timeout=30,
        )
        response.raise_for_status()
        task = response.json()

        if task["status"] == "completed":
            return task["results"]
        if task["status"] == "failed":
            raise RuntimeError(task.get("error", "Task failed"))

        time.sleep(5)

    raise TimeoutError("Task timed out")


task_id = create_image_task("Une affiche produit propre, fond blanc, éclairage studio doux")
results = wait_for_task(task_id)
print(results[0])
```

## Limites de fréquence des requêtes

Les limites de fréquence des requêtes EvoLink sont configurées par modèle.

Les limites de RPM, de concurrence et de soumission de tâches peuvent varier selon le modèle. Les limites réelles dépendent du type de modèle, de la capacité du service amont, du niveau du compte et de la disponibilité en temps réel. Les modèles texte légers prennent généralement en charge des fréquences plus élevées, tandis que les modèles de génération d'images et de vidéos peuvent avoir des limites plus basses, car les tâches durent plus longtemps et consomment davantage de ressources amont.

Pour les modèles de génération asynchrone, une réponse API réussie signifie seulement que la tâche a été acceptée ou créée ; elle ne signifie pas que la tâche est terminée. Pour les scénarios à forte concurrence, mettez en place une file d'attente côté serveur et récupérez les résultats finaux via l'API de consultation des tâches ou des callbacks.

Si vous recevez régulièrement des erreurs HTTP 429, ou si votre activité nécessite des limites RPM ou de concurrence plus élevées, contactez [support@evolink.ai](mailto:support@evolink.ai). Nous évaluerons la demande selon votre cas d'utilisation et la capacité amont disponible.

## Recommandations de production

<CardGroup cols={2}>
  <Card title="Gestion des clés" icon="shield">
    Stockez les API Keys dans des variables d'environnement ou un gestionnaire de secrets, et utilisez des clés distinctes selon les environnements.
  </Card>

  <Card title="Interrogation des tâches" icon="clock">
    Définissez l'intervalle d'interrogation selon le type de tâche. Les tâches image peuvent être interrogées plus souvent ; les tâches vidéo devraient l'être moins fréquemment.
  </Card>

  <Card title="Gestion des erreurs" icon="server">
    Gérez les états `failed` et les erreurs HTTP, notamment les limites de fréquence, le solde insuffisant et les erreurs de paramètres.
  </Card>

  <Card title="Stockage des résultats" icon="download">
    Les URL de résultats expirent. En production, téléchargez et stockez les fichiers terminés dans votre propre système.
  </Card>
</CardGroup>

## Étapes suivantes

<CardGroup cols={3}>
  <Card title="API Image" icon="image" href="/fr/api-manual/image-series/gpt-image-2/gpt-image-2-image-generation">
    Consulter les paramètres, exemples et structures de réponse de GPT Image 2.
  </Card>

  <Card title="API Vidéo" icon="video" href="/fr/api-manual/video-series/seedance2.0/seedance-2.0-overview">
    Consulter les capacités texte-vers-vidéo, image-vers-vidéo et référence-vers-vidéo de Seedance 2.0.
  </Card>

  <Card title="Gestion des tâches" icon="list-check" href="/fr/api-manual/task-management/get-task-detail">
    Consulter les requêtes de statut, les champs de résultat et la structure d'erreur des tâches.
  </Card>
</CardGroup>