Comment utiliser l’API Kling 2.6 sur PoYo : guide complet pour les développeurs

Mise à jour 2026 : l’API Kling 2.6 est disponible sur PoYo avec une tarification actuelle à partir de 65 crédits pour une vidéo de 5 secondes sans audio et de 120 crédits pour une vidéo de 5 secondes avec audio. Ce guide vous explique comment intégrer les capacités audio natives synchronisées de Kling 2.6 dans vos applications.

Premiers pas avec l’API Kling 2.6

Étape 1 : Configurer votre compte PoYo

Commencez par créer votre compte PoYo et obtenir vos identifiants API :

1. Inscrivez-vous sur PoYo.ai
2. Générez votre clé API dans le tableau de bord
3. Ajoutez des crédits à votre compte (la tarification de Kling 2.6 varie selon la durée et l’audio)

Étape 2 : Installer les dépendances requises

# For Node.js/JavaScript
npm install axios

# For Python
pip install requests

# For cURL (no installation needed)

Génération vidéo texte-vers-vidéo de base

Implémentation JavaScript/Node.js

const axios = require('axios');

const generateVideo = async (prompt, options = {}) => {
  const {
    duration = 5,       // 5 or 10 seconds
    aspectRatio = '16:9', // '1:1', '16:9', or '9:16'
    sound = true        // Enable native audio
  } = options;

  try {
    const response = await axios.post(
      'https://api.poyo.ai/api/generate/submit',
      {
        model: 'kling-2.6',
        callback_url: 'https://your-domain.com/callback', // Optional webhook
        input: {
          prompt: prompt,
          sound: sound,
          aspect_ratio: aspectRatio,
          duration: duration
        }
      },
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`,
          'Content-Type': 'application/json'
        }
      }
    );

    console.log('Task ID:', response.data.data.task_id);
    console.log('Status:', response.data.data.status);
    console.log('Created:', response.data.data.created_time);
    return response.data.data;
  } catch (error) {
    console.error('Error generating video:', error.response?.data || error.message);
  }
};

// Example: Generate a video with speech
generateVideo(
  'A man in a coffee shop looking at his laptop, smiling. He says "This AI is incredible!" in an excited voice.',
  { duration: 5, aspectRatio: '16:9', sound: true }
);

Implémentation Python

import requests
import json

def generate_video(prompt, api_key, duration=5, aspect_ratio='16:9', sound=True):
    url = "https://api.poyo.ai/api/generate/submit"

    payload = {
        "model": "kling-2.6",
        "callback_url": "https://your-domain.com/callback",  # Optional
        "input": {
            "prompt": prompt,
            "sound": sound,
            "aspect_ratio": aspect_ratio,
            "duration": duration
        }
    }

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

    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()

        result = response.json()
        print(f"Task ID: {result['data']['task_id']}")
        print(f"Status: {result['data']['status']}")
        print(f"Created: {result['data']['created_time']}")
        return result['data']

    except requests.exceptions.RequestException as e:
        print(f"Error generating video: {e}")
        return None

# Example usage
api_key = "YOUR_API_KEY"
result = generate_video(
    "A chef in a kitchen demonstrating how to chop vegetables. He narrates: 'First, we cut the onion in half.'",
    api_key,
    duration=10,
    aspect_ratio='16:9',
    sound=True
)

Implémentation cURL

curl -X POST "https://api.poyo.ai/api/generate/submit" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-2.6",
    "callback_url": "https://your-domain.com/callback",
    "input": {
      "prompt": "A woman sitting at a piano, playing a gentle melody. She sings softly: Welcome to my world of music.",
      "sound": true,
      "aspect_ratio": "16:9",
      "duration": 10
    }
  }'

Paramètres API

Corps de la requête

Format de réponse

{
  "code": 200,
  "data": {
    "task_id": "task-unified-1757165031-uyujaw3d",
    "status": "not_started",
    "created_time": "2026-06-12T10:30:00"
  }
}

Génération image-vers-vidéo

Transformez des images statiques en vidéos dynamiques avec Kling 2.6 :

const generateVideoFromImage = async (imageUrl, prompt, options = {}) => {
  const {
    duration = 5,
    aspectRatio = '16:9',
    sound = true
  } = options;

  try {
    const response = await axios.post(
      'https://api.poyo.ai/api/generate/submit',
      {
        model: 'kling-2.6',
        callback_url: 'https://your-domain.com/callback',
        input: {
          prompt: prompt,
          sound: sound,
          aspect_ratio: aspectRatio,
          duration: duration,
          image_urls: [imageUrl] // Reference image
        }
      },
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`,
          'Content-Type': 'application/json'
        }
      }
    );

    return response.data.data;
  } catch (error) {
    console.error('Error generating video:', error.response?.data || error.message);
  }
};

// Example: Animate a portrait photo
const result = await generateVideoFromImage(
  'https://example.com/portrait.jpg',
  'The person in the photo turns to smile at the camera and waves hello.',
  { duration: 5, sound: true }
);

Image-vers-vidéo avec Python

def generate_video_from_image(image_url, prompt, api_key, duration=5, aspect_ratio='16:9', sound=True):
    url = "https://api.poyo.ai/api/generate/submit"

    payload = {
        "model": "kling-2.6",
        "callback_url": "https://your-domain.com/callback",
        "input": {
            "prompt": prompt,
            "sound": sound,
            "aspect_ratio": aspect_ratio,
            "duration": duration,
            "image_urls": [image_url]
        }
    }

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

    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        return response.json()['data']
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None

# Example: Animate a product image
result = generate_video_from_image(
    "https://example.com/product.jpg",
    "The product rotates slowly, showcasing all angles. A voice says: Introducing our latest innovation.",
    api_key,
    duration=10,
    sound=True
)

Fonction audio native

Le paramètre sound active la génération audio native de Kling 2.6 :

Rédiger des prompts avec de l’audio

Lorsque sound: true, ajoutez des indications audio dans votre prompt :

// Prompt with speech
const speechPrompt = `
  A news anchor at a desk looks into the camera.
  He says: "Breaking news tonight, scientists have made an incredible discovery."
  The anchor gestures with his hands while speaking.
`;

// Prompt with sound effects
const sfxPrompt = `
  A cat walks across a wooden floor, meowing softly.
  Birds chirp outside the window.
  The cat jumps onto a couch with a soft thud.
`;

// Prompt with singing
const musicPrompt = `
  A woman with a guitar sits on a beach at sunset.
  She strums gently and sings a soft melody about the ocean.
  Waves crash softly in the background.
`;

// Prompt with multilingual speech
const multilingualPrompt = `
  Scene: Open office with printer sounds in background.
  [Male worker] asks: "报告快好了吗？Manager needs it this afternoon."
  [Female worker] replies: "Almost done. I'll send it in ten minutes."
`;

Vidéos avec audio vs vidéos silencieuses

// Generate with audio (120 credits for 5s)
const withAudio = await generateVideo(
  'A barista making coffee, explaining each step of the process.',
  { duration: 5, sound: true }
);

// Generate without audio (65 credits for 5s)
const silent = await generateVideo(
  'A timelapse of clouds moving across a mountain landscape.',
  { duration: 5, sound: false }
);

Gestion des résultats

Gestionnaire de webhook

const express = require('express');
const app = express();

app.use(express.json());

app.post('/webhook/callback', async (req, res) => {
  const { task_id, status, files, error_message } = req.body;

  console.log(`Task ${task_id}: ${status}`);

  if (status === 'finished' && files && files.length > 0) {
    const videoFile = files.find(f => f.file_type === 'video');
    if (videoFile) {
      console.log('Video URL:', videoFile.file_url);
      await processCompletedVideo(task_id, videoFile.file_url);
    }
  } else if (status === 'failed') {
    console.error('Generation failed:', error_message);
    await handleVideoError(task_id, error_message);
  }

  res.status(200).send('OK');
});

app.listen(3000);

Vérification manuelle du statut

const checkTaskStatus = async (taskId) => {
  try {
    const response = await axios.get(
      `https://api.poyo.ai/api/generate/status/${taskId}`,
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`
        }
      }
    );
    return response.data.data;
  } catch (error) {
    console.error('Error checking status:', error.message);
    return null;
  }
};

const waitForVideo = async (taskId, maxAttempts = 120) => {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const taskData = await checkTaskStatus(taskId);

    if (!taskData) break;

    console.log(`Status: ${taskData.status}, Progress: ${taskData.progress || 0}%`);

    if (taskData.status === 'finished') {
      console.log('Video generated successfully!');
      const videoFile = taskData.files?.find(f => f.file_type === 'video');
      if (videoFile) {
        console.log('Video URL:', videoFile.file_url);
      }
      return taskData;
    } else if (taskData.status === 'failed') {
      console.error('Generation failed:', taskData.error_message);
      return null;
    }

    // Wait 5 seconds between checks (video generation takes time)
    await new Promise(resolve => setTimeout(resolve, 5000));
  }

  console.error('Timeout waiting for video');
  return null;
};

// Complete workflow
const createVideo = async (prompt, options = {}) => {
  const generation = await generateVideo(prompt, options);
  if (!generation) return null;

  const result = await waitForVideo(generation.task_id);
  return result;
};

Vérification du statut avec Python

import time

def check_task_status(task_id, api_key):
    url = f"https://api.poyo.ai/api/generate/status/{task_id}"
    headers = {"Authorization": f"Bearer {api_key}"}

    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()['data']
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None

def wait_for_video(task_id, api_key, max_attempts=120):
    for attempt in range(max_attempts):
        task_data = check_task_status(task_id, api_key)

        if not task_data:
            break

        print(f"Status: {task_data['status']}, Progress: {task_data.get('progress', 0)}%")

        if task_data['status'] == 'finished':
            print("Video generated successfully!")
            video_file = next(
                (f for f in task_data.get('files', []) if f['file_type'] == 'video'),
                None
            )
            if video_file:
                print(f"Video URL: {video_file['file_url']}")
            return task_data
        elif task_data['status'] == 'failed':
            print(f"Failed: {task_data.get('error_message')}")
            return None

        time.sleep(5)  # Wait 5 seconds

    print("Timeout")
    return None

# Complete workflow
def create_video(prompt, api_key, **options):
    generation = generate_video(prompt, api_key, **options)
    if not generation:
        return None
    return wait_for_video(generation['task_id'], api_key)

Gestion des erreurs

const robustVideoGeneration = async (prompt, options = {}, retries = 3) => {
  for (let attempt = 0; attempt < retries; attempt++) {
    try {
      const response = await axios.post(
        'https://api.poyo.ai/api/generate/submit',
        {
          model: 'kling-2.6',
          input: {
            prompt,
            sound: options.sound ?? true,
            aspect_ratio: options.aspectRatio ?? '16:9',
            duration: options.duration ?? 5
          }
        },
        {
          headers: {
            'Authorization': `Bearer YOUR_API_KEY`,
            'Content-Type': 'application/json'
          },
          timeout: 30000
        }
      );

      return response.data.data;

    } catch (error) {
      if (error.response) {
        const status = error.response.status;

        if (status === 401 || status === 403) {
          throw new Error('Authentication failed');
        }
        if (status === 400) {
          throw new Error(`Invalid request: ${error.response.data?.error}`);
        }
        if (status === 402) {
          throw new Error('Insufficient credits');
        }
      }

      if (attempt === retries - 1) throw error;

      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
};

Conseils d’ingénierie des prompts

Prompts vidéo efficaces

// Structure: Scene + Characters + Action + Audio cues
const effectivePrompts = [
  // Interview style
  `A business woman in a modern office, facing the camera.
   She speaks confidently: "Our company has grown 200% this year."
   She gestures with her hands while explaining.`,

  // Product demo
  `Close-up of hands opening a smartphone box.
   A voice narrates: "Unboxing the latest flagship device."
   The phone is lifted out, camera pans to show the screen.`,

  // Storytelling
  `A child runs through a sunlit meadow, laughing.
   Birds sing in the background.
   The child stops to pick a flower and smiles at the camera.`,

  // Educational
  `An animated diagram of the solar system.
   A narrator explains: "The Earth takes 365 days to orbit the sun."
   Planets rotate in their orbits.`
];

Conclusion

L’API Kling 2.6 sur PoYo offre une génération vidéo IA révolutionnaire avec des capacités audio natives. Créez des vidéos complètes avec une voix synchronisée, de la musique et des effets sonores via un seul appel API.

Pour plus de détails, consultez la documentation officielle de l’API Kling 2.6.

Prêt à commencer ? Obtenez votre clé API et créez dès aujourd’hui des vidéos IA avec audio natif.

---

Besoin d’aide ? Rejoignez notre communauté de développeurs ou découvrez d’autres tutoriels.