Risorse per sviluppatori

SDK

Installa un SDK RunAPI tipizzato, autenticalo con una Chiave API e scegli il ciclo di vita del Task più adatto alla tua applicazione.

Visualizza Markdown

Gli SDK di RunAPI forniscono client tipizzati per le famiglie di modelli supportate in JavaScript, Python, PHP, Java, Ruby e Go. Scegli il pacchetto linguistico per la famiglia di modelli che la tua applicazione utilizza.

Installa un SDK per modelli

Installa il pacchetto che corrisponde al tuo linguaggio e alla tua famiglia di modelli. Ad esempio, installa l’SDK JavaScript di Suno:

SHELL

npm install @runapi.ai/[email protected]

La stessa famiglia di modelli è disponibile tramite il gestore di pacchetti per ogni runtime supportato:

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]

Per Java, aggiungi il modulo Suno con Gradle o 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>

Autenticare il client

Imposta RUNAPI_API_KEY nell’ambiente prima di creare un client. L’SDK utilizza una Chiave API di RunAPI per lo stesso contesto account delle tue richieste REST e del workflow CLI.

SHELL

export RUNAPI_API_KEY="runapi_..."

Crea e ruota le chiavi nella Guida all’Autenticazione . Conserva le chiavi nel tuo gestore di segreti anziché nel codice sorgente dell’applicazione.

Lavorare con File e Upload

Ogni Provider Client espone le risorse persistenti files e uploads multiparte dal suo pacchetto principale. Il metodo files.create esistente crea ancora un URL temporaneo; usa files.createFile in JavaScript, Java e PHP, files.create_file in Python e Ruby, oppure Files.CreateFile in Go per creare un oggetto File persistente.

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);

Usa uploads.create, addPart, complete e cancel quando una richiesta è suddivisa in Parts. Python e Ruby usano add_part; Go usa AddPart. Consulta Files and Uploads per i limiti, esempi REST e il ciclo di vita completo.

Trascrivi l'audio in modo sincrono

L’SDK di trascrizione OpenAI carica un file audio locale e restituisce la trascrizione completata nella stessa richiesta. I formati di risposta JSON restituiscono un oggetto nativo del linguaggio; i formati testo, SRT e VTT restituiscono la stringa di risposta esatta.

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",
});

Consulta il Riferimento API per la Trascrizione Audio per i formati file, i campi specifici del modello e i formati di risposta.

Lavorare con Task asincroni

Molte operazioni multimediali sono asincrone. Usa create per inviare un Task e riceverne l’id immediatamente, get per recuperarne lo stato corrente, o run per inviare e fare polling finché non raggiunge uno stato terminale. In un gestore di richieste web, preferisci create più un callback o un successivo polling con get in modo che la richiesta non mantenga un worker aperto.

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()
);

Riutilizzare una Style Persona

Crea una Style Persona da un URL audio pubblico, quindi riutilizza il persona.id restituito con le quattro operazioni musicali supportate. persona_type: "style" applica caratteristiche di genere e umore riutilizzabili. Non garantisce la clonazione della voce della registrazione sorgente, la conservazione fedele del suo stile né alcuna particolare somiglianza con l’audio sorgente.

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,
});

Scegli il prossimo flusso di lavoro

Usa un SDK quando la tua applicazione trae vantaggio dai costruttori di richieste tipizzati e dagli helper Task nativi del linguaggio. Usa la RunAPI CLI per l’automazione shell, i controlli locali e il debugging delle callback. Per i campi di richiesta esatti, le risposte dei Task e gli errori, usa il Riferimento API.

Vidu Q4

I pacchetti Vidu forniscono immagine-video e riferimento-video risorse con assistenti di creazione, recupero e attività asincrone. Utilizzare vidu-q4-image-to-video o vidu-q4-reference-to-video per risorsa corrispondente. I nomi dei pacchetti sono @runapi.ai/vidu per JavaScript, runapi-vidu per Python e Ruby, runapi-ai/vidu per PHP, ai.runapi:runapi-vidu per Java e github.com/runapi-ai/vidu-sdk/go per Go.

Consulta i requisiti delle immagini di riferimento e dei file MP3 nella guida all’API delle attività。 Consulta anche Prezzi immagine in video · Prezzi riferimenti in video。