Ressources pour développeurs

SDKs

Installez un SDK RunAPI typé, authentifiez-le avec une clé API et choisissez le cycle de vie de tâche adapté à votre application.

Voir en Markdown

Les SDKs RunAPI fournissent des clients typés pour les familles de modèles supportées en JavaScript, Python, PHP, Java, Ruby et Go. Choisissez le package de langage correspondant à la famille de modèles que votre application appelle.

Installer un SDK de modèle

Installez le paquet correspondant à votre langage et à votre famille de modèles. Par exemple, installez le SDK JavaScript de Suno :

SHELL

npm install @runapi.ai/[email protected]

La même famille de modèles est disponible via le gestionnaire de paquets pour chaque runtime pris en charge :

SHELL

pip install runapi-suno==0.6.0
composer require runapi-ai/suno:0.4.0
gem install runapi-suno --version 0.6.0
go get github.com/runapi-ai/suno-sdk/[email protected]

Pour Java, ajoutez le module Suno avec Gradle ou Maven :

KOTLIN

dependencies {
  implementation("ai.runapi:runapi-suno:0.5.0")
}

XML

<dependency>
  <groupId>ai.runapi</groupId>
  <artifactId>runapi-suno</artifactId>
  <version>0.5.0</version>
</dependency>

Authentifier le client

Définissez RUNAPI_API_KEY dans l’environnement avant de créer un client. Le SDK utilise une clé API RunAPI pour le même contexte de compte que vos requêtes REST et votre workflow CLI.

SHELL

export RUNAPI_API_KEY="runapi_..."

Créez et faites tourner des clés dans le Guide d’authentification. Conservez les clés dans votre gestionnaire de secrets plutôt que dans le code source de l’application.

Travailler avec les fichiers et les téléversements

Chaque client fournisseur expose des ressources files persistantes et des ressources uploads multipart depuis son package principal. La méthode existante files.create crée toujours une URL temporaire ; utilisez files.createFile en JavaScript, Java et PHP, files.create_file en Python et Ruby, ou Files.CreateFile en Go pour créer un objet File persistant.

JAVASCRIPT

const file = await client.files.createFile({
  file: new Blob([fileBytes], { type: "application/pdf" }),
  filename: "knowledge.pdf",
  purpose: "user_data",
});

const bytes = await client.files.content(file.id);
await client.files.deleteFile(file.id);

Utilisez uploads.create, addPart, complete et cancel lorsqu’une requête est divisée en Parts. Python et Ruby utilisent add_part ; Go utilise AddPart. Consultez Files and Uploads pour les limites, les exemples REST et le cycle de vie complet.

Transcrire l'audio de manière synchrone

Le SDK de transcription OpenAI téléverse un fichier audio local et retourne la transcription complétée dans la même requête. Les formats de réponse JSON retournent un objet natif au langage ; les formats text, SRT et VTT retournent la chaîne de réponse exacte.

JAVASCRIPT

import { OpenaiTranscriptionClient } from "@runapi.ai/openai-transcription";

const client = new OpenaiTranscriptionClient();
const transcript = await client.speechToText.run({
  file: new Blob([audioBytes], { type: "audio/mpeg" }),
  filename: "interview.mp3",
  response_format: "json",
});

Consultez la référence API de transcription audio pour les formats de fichiers, les champs spécifiques au modèle et les formats de réponse.

Travailler avec les tâches asynchrones

De nombreuses opérations multimédias sont asynchrones. Utilisez create pour soumettre une tâche et recevoir son identifiant immédiatement, get pour récupérer son état actuel, ou run pour soumettre et interroger jusqu’à ce qu’elle atteigne un état terminal. Dans un gestionnaire de requête web, préférez create associé à un rappel ou à un get différé afin que la requête ne monopolise pas un worker.

JavaScript

JAVASCRIPT

import { SunoClient } from "@runapi.ai/suno";

const client = new SunoClient();
const result = await client.textToMusic.run({
  model: "suno-v5",
  vocal_mode: "auto_lyrics",
  prompt: "A short piano theme",
});

console.log(result.audios[0].audio_url);

Python

PYTHON

from runapi.suno import SunoClient

client = SunoClient()
result = client.text_to_music.run(
    model="suno-v4.5-plus",
    vocal_mode="auto_lyrics",
    prompt="A short piano theme",
)

print(result.audios[0].audio_url)

PHP

<?php

use RunApi\Suno\SunoClient;

$client = new SunoClient();
$result = $client->textToMusic->run([
    'model' => 'suno-v5.5',
    'vocal_mode' => 'auto_lyrics',
    'prompt' => 'A short piano theme',
]);

print_r($result->toArray());

Ruby

RUBY

require "runapi/suno"

client = RunApi::Suno::Client.new
result = client.text_to_music.run(
  model: "suno-v4.5-plus",
  vocal_mode: "auto_lyrics",
  prompt: "A short piano theme"
)

puts result.dig("audios", 0, "audio_url")

Go

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/runapi-ai/core-sdk/go/option"
    "github.com/runapi-ai/suno-sdk/go/suno"
)

func main() {
    client, err := suno.NewClient(option.WithAPIKey(os.Getenv("RUNAPI_API_KEY")))
    if err != nil {
        log.Fatal(err)
    }

    result, err := client.TextToMusic.Run(context.Background(), suno.TextToMusicParams{
        SunoBaseParams: suno.SunoBaseParams{Model: suno.ModelV45Plus},
        VocalMode: suno.VocalModeAutoLyrics,
        Prompt:    "A short piano theme",
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(result.ID)
}

Java

JAVA

import ai.runapi.suno.SunoClient;
import ai.runapi.suno.types.CompletedTextToMusicResponse;
import ai.runapi.suno.types.TextToMusicModel;
import ai.runapi.suno.types.TextToMusicParams;

SunoClient client = SunoClient.builder()
    .apiKey(System.getenv("RUNAPI_API_KEY"))
    .build();

CompletedTextToMusicResponse result = client.textToMusic().run(
    TextToMusicParams.builder()
        .model(TextToMusicModel.SUNO_V5)
        .vocalMode("auto_lyrics")
        .prompt("A short piano theme")
        .build()
);

Réutiliser un Style Persona

Créez un Style Persona à partir d’une URL audio publique, puis réutilisez le persona.id renvoyé avec les quatre opérations musicales prises en charge. persona_type: "style" applique des caractéristiques de genre et d’ambiance réutilisables. Cela ne garantit pas le clonage de la voix de l’enregistrement source, la préservation sans perte de son style, ni aucune similarité particulière avec l’audio source.

JAVASCRIPT

import { SunoClient } from "@runapi.ai/suno";

const client = new SunoClient();
const referenceAudioUrl = "https://cdn.runapi.ai/public/samples/music.mp3";

const sampled = await client.addSamples.run({
  model: "suno-v5",
  audio_url: referenceAudioUrl,
  start_seconds: 0,
  end_seconds: 30,
});
const sourceAudioId = sampled.audios?.[0]?.id;
if (!sourceAudioId) throw new Error("The sample Task did not return an audio ID");

const { persona } = await client.generatePersona.run({
  task_id: sampled.id,
  audio_id: sourceAudioId,
  name: "Studio Style",
  description: "A warm and expressive acoustic pop style.",
});
const textToMusic = await client.textToMusic.run({
  model: "suno-v5",
  vocal_mode: "auto_lyrics",
  prompt: "An uplifting acoustic pop song about a rainy city night",
  persona_id: persona.id,
  persona_type: "style",
});

const coverAudio = await client.coverAudio.run({
  model: "suno-v5",
  upload_url: referenceAudioUrl,
  vocal_mode: "auto_lyrics",
  prompt: "Rework the reference track as acoustic pop",
  persona_id: persona.id,
  persona_type: "style",
});

const createMashup = await client.createMashup.run({
  model: "suno-v5",
  upload_url_list: [
    referenceAudioUrl,
    "https://cdn.runapi.ai/public/samples/audio-2.mp3",
  ],
  vocal_mode: "auto_lyrics",
  prompt: "Blend both tracks into an energetic acoustic pop mashup",
  persona_id: persona.id,
  persona_type: "style",
});

const extendMusic = await client.extendMusic.run({
  model: "suno-v5",
  upload_url: referenceAudioUrl,
  parameter_mode: "custom",
  instrumental: false,
  prompt: "Continue the arrangement with a brighter chorus",
  style: "Acoustic pop with warm piano",
  title: "Brighter Chorus",
  continue_at: 60,
  persona_id: persona.id,
  persona_type: "style",
});

console.log({
  textToMusic: textToMusic.audios[0]?.audio_url,
  coverAudio: coverAudio.audios[0]?.audio_url,
  createMashup: createMashup.audios[0]?.audio_url,
  extendMusic: extendMusic.audios[0]?.audio_url,
});

Choisir le prochain flux de travail

Utilisez un SDK lorsque votre application bénéficie de constructeurs de requêtes typés et d’assistants Task natifs au langage. Utilisez la CLI RunAPI pour l’automatisation shell, les vérifications locales et le débogage des callbacks. Pour les champs de requête exacts, les réponses de Task et les erreurs, utilisez la Référence API.

Vidu Q4

Les packagesVidufournissent des ressources image-vidéo et référence-vidéo avec des assistants de création, de récupération et de tâches asynchrones. Utilisez vidu-q4-image-to-video ou vidu-q4-reference-to-video pour la ressource correspondante. Les noms de packages sont @runapi.ai/vidu pourJavaScript, runapi-vidu pourPythonetRuby, runapi-ai/vidu pourPHP, ai.runapi:runapi-vidu pourJavaet github.com/runapi-ai/vidu-sdk/go pourGo.

Consultez les exigences des images de référence et des fichiers MP3 dans le guide de l’API des tâches。 Consultez aussi Tarifs image vers vidéo · Tarifs références vers vidéo。