Tutoriel API 2slides - Guide Complet pour la Génération de Présentations par IA

Bienvenue dans le guide complet de l'API 2slides ! Ce tutoriel vous expliquera tout ce que vous devez savoir pour intégrer la génération de présentations assistée par IA dans vos applications.

Aperçu

L'API 2slides vous permet de générer des présentations professionnelles par programmation à l'aide de l'IA. Grâce à la prise en charge de plusieurs types de présentations, notamment les chronologies, les feuilles de route, les cartes mentales et bien plus encore, vous pouvez créer des diapositives époustouflantes à partir d'une simple saisie de texte.

Fonctionnalités Clés

• Génération assistée par IA : Créez automatiquement des présentations professionnelles à partir de texte
• Plusieurs types de modèles : Prise en charge des chronologies, feuilles de route, cartes mentales, pitch decks, infographies et plus encore
• Prise en charge multilingue : Générez du contenu dans plusieurs langues
• Riche bibliothèque de modèles : Accès à des centaines de modèles conçus par des professionnels
• Modèles personnalisés : Téléchargez et utilisez vos propres modèles de diapositives personnalisés
• Recherche de modèles : Recherchez des modèles par nom, mots-clés et balises
• Options de téléchargement : Obtenez des présentations au format PowerPoint (.pptx)
• Suivi du statut en temps réel : Surveillez la progression de la génération avec les points d'accès de statut de travail

Types de Présentations Mis en Avant

Tous les modèles de présentation sont disponibles ici : 2slides Templates. Plus précisément, certains types de présentations sont particulièrement efficaces pour des objectifs et des scénarios spécifiques.

1. Timeline Slides - Parfait pour les chronologies de projets et les événements historiques
2. Roadmap Slides - Idéal pour les feuilles de route produits et la planification de projets
3. Mind Map Slides - Excellent pour la cartographie conceptuelle et la structuration des connaissances

Démarrage

URL de base

Toutes les requêtes API doivent être effectuées vers :

https://2slides.com

Prérequis

1. Configuration du compte : Créez un compte sur 2slides.com
2. Clé API : Générez une clé API depuis votre page de gestion des API
3. Crédits : Assurez-vous d'avoir suffisamment de crédits pour la génération de diapositives (10 crédits par page de diapositive)

Démarrage rapide

1. Obtenez votre clé API depuis la page de gestion des API
2. Recherchez un thème en utilisant le point d'accès de recherche de thèmes, ou parcourez les modèles pour obtenir l'ID du thème de diapositive
3. Générez des diapositives avec votre contenu et l'ID de thème sélectionné. Cela prend en charge à la fois l'appel synchrone avec les diapositives de résultat renvoyées et l'appel asynchrone avec l'ID de travail renvoyé. Si vous utilisez l'appel synchrone, les étapes 4 et 5 ne sont pas nécessaires.
4. Vérifiez le statut du travail jusqu'à son achèvement, l'URL de téléchargement des diapositives générées sera fournie.
5. Téléchargez votre présentation en utilisant l'URL de téléchargement fournie.

Authentification

Tous les points d'accès API nécessitent une authentification à l'aide d'une clé API. Vous pouvez gérer vos clés API via l'interface de gestion des API.

Format de la clé API

Les clés API suivent ce format :

sk-2slides-{64-character-hex-string}

Méthodes d'authentification

En-tête d'autorisation

Authorization: Bearer sk-2slides-your-api-key-here

Gestion des clés API

• Nombre maximal de clés : Chaque utilisateur peut créer jusqu'à 10 clés API
• Nommage des clés : Donnez à vos clés des noms descriptifs pour une identification facile
• Sécurité : Gardez vos clés API sécurisées et ne les partagez jamais publiquement
• Rotation : Faites pivoter régulièrement vos clés API pour une sécurité renforcée

⚠️ Avis de sécurité important : La plateforme 2slides NE stocke PAS vos clés API en texte clair pour des raisons de sécurité. Une fois générée, vous devez copier et stocker votre clé API en toute sécurité immédiatement. Si vous perdez votre clé API, vous devrez en générer une nouvelle car l'originale ne peut pas être récupérée.

Points d'accès API

1. Générer des diapositives (Fast PPT)

Générez des diapositives (Fast PPT) à partir d'une saisie de texte en utilisant un thème spécifique.

Point d'accès :

En-têtes :

Authorization: Bearer sk-2slides-your-api-key-here
Content-Type: application/json

Corps de la requête :

{
  "userInput": "Your presentation content here...",
  "themeId": "theme-uuid-here",
  "responseLanguage": "Auto"
}

Paramètres :

• userInput
  (requis) : Le contenu pour lequel vous souhaitez générer des diapositives
• themeId
  (requis) : ID du thème à utiliser pour la génération de diapositives. Cela peut être :
  • Des thèmes publics de la galerie de modèles
  • Vos propres thèmes personnalisés téléchargés (accessibles via votre compte)
• responseLanguage
  (facultatif) : Langue des diapositives générées. Utilisez « Auto » pour la détection automatique
• mode
  (facultatif) : Appel synchrone (sync) ou asynchrone (async), « sync » est la valeur par défaut

Langues disponibles :

• Auto
  - Détection automatique de la langue à partir de l'entrée (par défaut)
• English
  - Anglais
• Simplified Chinese
  - Chinois simplifié
• Traditional Chinese
  - Chinois traditionnel
• Spanish
  - Espagnol
• Arabic
  - Arabe
• Portuguese
  - Portugais
• Indonesian
  - Indonésien
• Japanese
  - Japonais
• Russian
  - Russe
• Hindi
  - Hindi
• French
  - Français
• German
  - Allemand
• Vietnamese
  - Vietnamien
• Turkish
  - Turc
• Polish
  - Polonais
• Italian
  - Italien
• Korean
  - Coréen

Réponse en mode asynchrone :

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "processing",
    "message": "Slides generation started. Use the jobId to check status.",
    "credits": {
      "current": 150,
      "required": 30
    }
  }
}

Réponse en mode synchrone :

{
  "success": true,
  "data": {
    "jobId": "1pFqIww3JjquQ1T3Ysmw1",
    "status": "success",
    "message": "Slides generated successfully",
    "downloadUrl": "https://presigned-url-here",
    "createdAt": 1760347015388,
    "updatedAt": 1760347048261,
    "duration": 32694,
    "slidePageCount": 9
  }
}

2. Vérifier le statut du travail (Fast PPT)

Vérifiez le statut d'un travail de génération de diapositives (Fast PPT) et obtenez les résultats une fois terminé.

Point d'accès :

En-têtes :

Authorization: Bearer sk-2slides-your-api-key-here

Exemples de réponses :

En cours de traitement :

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "processing",
    "message": "Slides generation in progress",
    "createdAt": 1703123456789,
    "updatedAt": 1703123460000
  }
}

Succès :

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "success",
    "message": "Slides generated successfully",
    "downloadUrl": "https://presigned-url-here",
    "createdAt": 1703123456789,
    "updatedAt": 1703123500000,
    "duration": 33211,
    "slidePageCount": 3
  }
}

Échec :

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "failed",
    "message": "Slides generation failed",
    "errorMessage": "Insufficient credits for generation",
    "createdAt": 1703123456789,
    "updatedAt": 1703123460000
  }
}

3. Créer des diapositives comme celle-ci (Nano Banana Pro)

Générez des diapositives (Nano Banana Pro) à partir d'une image de référence. Ce point d'accès utilise le mode synchrone et génère automatiquement un PDF lorsque toutes les diapositives sont terminées.

Point d'accès :

En-têtes :

Authorization: Bearer sk-2slides-your-api-key-here
Content-Type: application/json

Corps de la requête :

{
  "userInput": "Your presentation content here...",
  "referenceImageUrl": "https://example.com/reference-image.jpg",
  "responseLanguage": "Auto",
  "aspectRatio": "16:9",
  "resolution": "2K",
  "page": 1
}

Paramètres :

• userInput
  (requis) : Le contenu pour lequel vous souhaitez générer des diapositives
• referenceImageUrl
  (requis) : URL de l'image de référence à suivre pour le style de conception. Prend en charge :
  • URL HTTP/HTTPS
  • URL de données Base64 (data:image/...)
• responseLanguage
  (facultatif) : Langue des diapositives générées. Utilisez « Auto » pour la détection automatique (par défaut : « Auto »)
• aspectRatio
  (facultatif) : Ratio d'aspect pour les diapositives. Format : « largeur:hauteur » (par défaut : « 16:9 »)
• resolution
  (facultatif) : Résolution pour les images de diapositives. Options : « 1K », « 2K », « 4K » (par défaut : « 2K »)
• page
  (facultatif) : Nombre de diapositives à générer. Utilisez 0 pour la détection automatique. Spécifiez un nombre (>=1, max : 100) pour forcer ce nombre de diapositives. Par défaut : 1.
• contentDetail
  (facultatif) : Niveau de détail du contenu pour les diapositives. Options : « concise » (bref, axé sur les mots-clés) ou « standard » (complet, détaillé). Par défaut : « concise ».

Réponse :

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "success",
    "message": "Successfully generated 5 slides",
    "downloadUrl": "https://presigned-url-to-pdf.pdf",
    "jobUrl": "https://2slides.com/workspace?jobId=job-uuid-here",
    "createdAt": 1703123456789,
    "updatedAt": 1703123500000,
    "slidePageCount": 5,
    "successCount": 5,
    "failedCount": 0
  }
}

Valeurs de statut :

• success
  : Toutes les diapositives ont été générées avec succès, le PDF est disponible
• partial
  : Certaines diapositives n'ont pas pu être générées
• failed
  : Toutes les diapositives n'ont pas pu être générées

Remarque : Ce point d'accès fonctionne en mode synchrone et attendra que toutes les diapositives soient générées avant de renvoyer une réponse.

4. Rechercher des thèmes (Fast PPT)

Recherchez des thèmes de diapositives (Fast PPT) disponibles par mot-clé. Cela inclut à la fois les thèmes publics et vos propres thèmes personnalisés téléchargés.

Point d'accès :

En-têtes :

Authorization: Bearer sk-2slides-your-api-key-here

Paramètres de requête :

• query
  (requis) : Mot-clé à rechercher dans le nom, la description et les balises du thème
• limit
  (facultatif) : Nombre maximal de résultats (1-100, par défaut 20)

Exemple de requête :

GET /api/v1/themes/search?query=timeline&limit=10

Réponse :

{
  "success": true,
  "data": {
    "total": 25,
    "themes": [
      {
        "id": "theme-uuid-1",
        "name": "Modern Timeline",
        "description": "Clean and modern timeline template for project presentations",
        "tags": "timeline, modern, project, clean",
        "themeURL": "https://2slides.com/templates/st-1759917935785-nx0z6ae54"
      },
      {
        "id": "theme-uuid-2",
        "name": "Business Roadmap",
        "description": "Professional roadmap template for business planning",
        "tags": "roadmap, business, planning, professional",
        "themeURL": "https://2slides.com/templates/st-1755509077270-sftfm616s"
      }
    ]
  }
}

Limitation de débit

L'API implémente une limitation de débit pour garantir une utilisation équitable et la stabilité du système. Différents points d'accès ont des limites de débit différentes :

En-têtes de limitation de débit

Lorsque les limites de débit sont dépassées, l'API renvoie une réponse

avec ces en-têtes :

HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 6
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1703123600
Retry-After: 45

Gestion des limites de débit

Vous devez gérer attentivement la limite de débit des appels API, voici un exemple en Javascript.

async function makeApiRequest(url, options) {
  try {
    const response = await fetch(url, options);
    
    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      console.log(`Limite de débit atteinte. Réessayer après ${retryAfter} secondes`);
      await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
      return makeApiRequest(url, options); // Retry
    }
    
    return response;
  } catch (error) {
    console.error('La requête API a échoué :', error);
    throw error;
  }
}

Système de crédits

2slides utilise un système basé sur des crédits pour la génération de diapositives. Chaque page de diapositive coûte 10 crédits.

Règles de crédit

• Nouveaux utilisateurs : Recevez 880 crédits gratuits lors de l'inscription
• Coût : 10 crédits par page de diapositive (Fast PPT), 100 crédits par page de diapositive Nano Banana Pro 1K/2K, 200 crédits par page de diapositive Nano Banana Pro 4K
• Minimum : Les utilisateurs ont besoin d'au moins 10 crédits pour commencer la génération
• Déduction : Les crédits ne sont déduits qu'après une génération réussie
• Remboursements : Les crédits sont remboursés si la génération échoue

Vérification des crédits

Vous pouvez vérifier votre solde de crédits via le tableau de bord de votre compte ou en examinant les informations de crédit dans les réponses de l'API.

Achat de crédits

Des crédits supplémentaires peuvent être achetés via la page de tarification en utilisant diverses méthodes de paiement.

Exemples

Exemple de flux de travail complet

Voici un exemple complet de génération de diapositives à l'aide de l'API 2slides en Javascript et Python :

const API_KEY = 'sk-2slides-your-api-key-here';
const BASE_URL = 'https://2slides.com';

async function generateSlides() {
  try {
    // Step 1: Search for a theme
    const themeResponse = await fetch(
      `${BASE_URL}/api/v1/themes/search?query=timeline&limit=5`,
      {
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    const themeData = await themeResponse.json();
    const themeId = themeData.data.themes[0].id;
    
    // Step 2: Generate slides
    const generateResponse = await fetch(
      `${BASE_URL}/api/v1/slides/generate`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          userInput: "Create a timeline for our product development: Q1 - Research and planning, Q2 - MVP development, Q3 - Beta testing, Q4 - Public launch",
          themeId: themeId,
          responseLanguage: "English",
          mode: "async"
        })
      }
    );
    
    const generateData = await generateResponse.json();
    const jobId = generateData.data.jobId;
    
    // Step 3: Poll for completion
    let jobStatus;
    do {
      await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds
      
      const statusResponse = await fetch(
        `${BASE_URL}/api/v1/jobs/${jobId}`,
        {
          headers: {
            'Authorization': `Bearer ${API_KEY}`
          }
        }
      );
      
      jobStatus = await statusResponse.json();
      console.log(`Statut : ${jobStatus.data.status}`);
      
    } while (jobStatus.data.status === 'processing' || jobStatus.data.status === 'pending');
    
    // Step 4: Handle result
    if (jobStatus.data.status === 'success') {
      console.log('Diapositives générées avec succès !');
      console.log('URL de téléchargement :', jobStatus.data.downloadUrl);
      console.log('Pages générées :', jobStatus.data.slidePageCount);
      
      // Download the file
      const downloadResponse = await fetch(jobStatus.data.downloadUrl);
      const blob = await downloadResponse.blob();
      
      // Create download link
      const url = window.URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = 'presentation.pptx';
      a.click();
      window.URL.revokeObjectURL(url);
      
    } else {
      console.error('Échec de la génération :', jobStatus.data.errorMessage);
    }
    
  } catch (error) {
    console.error('Erreur :', error);
  }
}

// Exécuter l'exemple
generateSlides();

Exemple Python

import requests
import time
import json

API_KEY = 'sk-2slides-your-api-key-here'
BASE_URL = 'https://2slides.com'

def generate_slides():
    headers = {
        'Authorization': f'Bearer {API_KEY}',
        'Content-Type': 'application/json'
    }
    
    try:
        # Step 1: Search for a theme
        theme_response = requests.get(
            f'{BASE_URL}/api/v1/themes/search',
            params={'query': 'roadmap', 'limit': 5},
            headers=headers
        )
        theme_data = theme_response.json()
        theme_id = theme_data['data']['themes'][0]['id']
        
        # Step 2: Generate slides
        generate_payload = {
            'userInput': 'Create a product roadmap for our mobile app: Phase 1 - Core features, Phase 2 - Advanced features, Phase 3 - AI integration',
            'themeId': theme_id,
            'responseLanguage': 'English',
            'mode': 'async'
        }
        
        generate_response = requests.post(
            f'{BASE_URL}/api/v1/slides/generate',
            headers=headers,
            json=generate_payload
        )
        generate_data = generate_response.json()
        job_id = generate_data['data']['jobId']
        
        # Step 3: Poll for completion
        while True:
            time.sleep(2)  # Wait 2 seconds
            
            status_response = requests.get(
                f'{BASE_URL}/api/v1/jobs/{job_id}',
                headers=headers
            )
            status_data = status_response.json()
            status = status_data['data']['status']
            
            print(f'Statut : {status}')
            
            if status in ['success', 'failed']:
                break
        
        # Step 4: Handle result
        if status == 'success':
            print('Diapositives générées avec succès !')
            print(f'URL de téléchargement : {status_data["data"]["downloadUrl"]}')
            print(f'Pages générées : {status_data["data"]["slidePageCount"]}')
            
            # Download the file
            download_response = requests.get(status_data['data']['downloadUrl'])
            with open('presentation.pptx', 'wb') as f:
                f.write(download_response.content)
            print('Fichier téléchargé sous le nom presentation.pptx')
            
        else:
            print(f'Échec de la génération : {status_data["data"]["errorMessage"]}')
            
    except Exception as error:
        print(f'Erreur : {error}')

# Exécuter l'exemple
generate_slides()

Exemples cURL

Rechercher des thèmes :

curl -X GET "https://2slides.com/api/v1/themes/search?query=timeline&limit=5" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here" \
  -H "Content-Type: application/json"

Générer des diapositives :

curl -X POST "https://2slides.com/api/v1/slides/generate" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "userInput": "Create a timeline for our project milestones",
    "themeId": "theme-uuid-here",
    "responseLanguage": "English",
    "mode": "async"
  }'

Vérifier le statut du travail :

curl -X GET "https://2slides.com/api/v1/jobs/job-uuid-here" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here"

Gestion des erreurs

L'API utilise les codes de statut HTTP standard et renvoie des informations d'erreur détaillées au format JSON.

Réponses d'erreur courantes

400 Requête incorrecte :

{
  "success": false,
  "error": "userInput est requis et doit être une chaîne non vide"
}

401 Non autorisé :

{
  "success": false,
  "error": "Authentification requise"
}

403 Interdit :

{
  "success": false,
  "error": "Accès refusé"
}

404 Non trouvé :

{
  "success": false,
  "error": "Thème non trouvé"
}

429 Trop de requêtes :

{
  "success": false,
  "error": "Limite de débit dépassée"
}

500 Erreur interne du serveur :

{
  "success": false,
  "error": "Erreur interne du serveur"
}

Bonnes pratiques de gestion des erreurs

async function handleApiRequest(url, options) {
  try {
    const response = await fetch(url, options);
    const data = await response.json();
    
    if (!response.ok) {
      switch (response.status) {
        case 400:
          throw new Error(`Requête incorrecte : ${data.error}`);
        case 401:
          throw new Error('Échec de l\'authentification. Veuillez vérifier votre clé API.');
        case 403:
          throw new Error('Accès refusé. Vous n\'avez peut-être pas la permission pour cette ressource.');
        case 404:
          throw new Error('Ressource non trouvée.');
        case 429:
          throw new Error('Limite de débit dépassée. Veuillez réessayer plus tard.');
        case 500:
          throw new Error('Erreur du serveur. Veuillez réessayer plus tard.');
        default:
          throw new Error(`Erreur API : ${data.error || 'Erreur inconnue'}`);
      }
    }
    
    return data;
  } catch (error) {
    if (error.name === 'TypeError' && error.message.includes('fetch')) {
      throw new Error('Erreur réseau. Veuillez vérifier votre connexion internet.');
    }
    throw error;
  }
}

Bonnes pratiques

1. Sécurité de la clé API

• Ne jamais exposer les clés API dans le code côté client ou les dépôts publics
• Utiliser des variables d'environnement pour stocker les clés API en toute sécurité
• Faire pivoter les clés régulièrement pour une sécurité renforcée
• Surveiller l'utilisation des clés via le tableau de bord de gestion des API
• Stocker les clés en toute sécurité : N'oubliez pas que 2slides ne stocke pas vos clés API, vous devez donc les garder en sécurité
• Sauvegarder vos clés : Stockez les clés API dans un gestionnaire de mots de passe sécurisé ou un stockage chiffré

2. Utilisation efficace de l'API

• Mettre en cache les résultats de recherche de thèmes pour éviter les requêtes répétées
• Implémenter des intervalles d'interrogation appropriés pour les vérifications de statut de travail (2-5 secondes)
• Gérer les limites de débit avec élégance avec un backoff exponentiel
• Opérations par lots lorsque cela est possible pour réduire les appels API

3. Gestion des erreurs

• Toujours vérifier les codes de statut de réponse
• Implémenter une logique de nouvelle tentative pour les échecs transitoires
• Enregistrer les erreurs de manière appropriée pour le débogage
• Fournir des messages d'erreur conviviaux

4. Optimisation des performances

• Utiliser des intervalles d'interrogation appropriés pour éviter les requêtes inutiles
• Implémenter des délais d'attente de requête pour éviter les requêtes bloquées
• Mettre en cache les données fréquemment utilisées comme les informations de thème
• Surveiller votre consommation de crédits pour éviter les frais inattendus

5. Directives de contenu

• Fournir une entrée claire et structurée pour une meilleure génération de diapositives
• Utiliser des thèmes appropriés pour votre type de contenu
• Spécifier la langue si nécessaire pour le contenu international
• Garder le contenu concis pour une mise en page optimale des diapositives

Support et ressources

Documentation et ressources

• Documentation API - Documentation API interactive et espace de test
• Galerie de modèles - Parcourir les modèles de diapositives disponibles
• Informations sur les tarifs - Forfaits de crédits et tarifs
• Blog - Dernières mises à jour et astuces

Obtenir de l'aide

• Espace de test API : Testez vos appels API directement dans le navigateur sur 2slides.com/api
• Tableau de bord du compte : Gérez votre consommation de crédits sur 2slides.com/account
• Support : Contactez le support via le site web principal

Communauté et mises à jour

• Mises à jour des fonctionnalités : Restez informé des nouvelles fonctionnalités et améliorations
• Bibliothèque de modèles : Ajouts réguliers de nouveaux modèles professionnels
• Améliorations de l'API : Améliorations continues des performances et des fonctionnalités de l'API

---

Conclusion

L'API 2slides offre un moyen puissant et flexible de générer des présentations professionnelles par programmation. Grâce à son ensemble complet de fonctionnalités, sa gestion robuste des erreurs et sa vaste bibliothèque de modèles, vous pouvez intégrer la génération de diapositives assistée par IA dans n'importe quelle application ou flux de travail.

Commencez dès aujourd'hui à créer des présentations incroyables avec l'API 2slides ! Visitez 2slides.com/api pour obtenir votre clé API et commencer à créer.