Clé API Suno : création et première requête avec reAPI

Pour obtenir une clé API Suno destinée à reAPI, connectez-vous à reAPI, ouvrez API Keys, puis créez une clé. Envoyez-la dans Authorization: Bearer <key> à https://reapi.ai/api/v1. Il s’agit d’un identifiant reAPI pour les endpoints reAPI, pas d’une clé de développeur délivrée par Suno.^[1]

Au 14 septembre 2026, les documents officiels Suno vérifiés pour cette série renvoient à une candidature de partenaire, plutôt qu’à un parcours public documenté de création de clé en libre-service. L’article sur l’état de l’API officielle explique cette distinction. Ce guide suit le parcours reAPI, de la création à la première requête et à un résultat audio terminé.^[2]

À retenir

• Créez une clé dans les paramètres API Keys et enregistrez-la lorsqu’elle apparaît : la documentation précise qu’elle n’est affichée en entier qu’une fois.^[1]
• Envoyez l’en-tête Bearer depuis votre serveur. Une connexion au site Suno ou un abonnement ne remplace pas cet identifiant.
• Envoyez model: "suno-music" et version: "V6" à l’endpoint de génération audio.^[3]
• Conservez l’id retourné, puis interrogez la tâche. HTTP 200 seul ne prouve pas que la musique est terminée avec succès.^[4]
• Une requête de chanson terminée coûte 60 crédits, soit 0,06 USD, pour deux prises. Le suivi est gratuit ; vérifiez le solde avant l’envoi.^[3]

Créer une clé API Suno pour passer par reAPI

Vous avez besoin d’un compte reAPI, d’un accès aux paramètres API Keys et d’assez de crédits pour l’opération choisie. Utilisez un terminal, Python avec requests, un environnement Node.js avec fetch intégré ou Go. Choisissez un exemple : exécuter les quatre crée quatre requêtes de génération.

1. Connectez-vous et ouvrez les paramètres API Keys.
2. Cliquez sur CREATE API KEY, le libellé observé sur la page actuelle. Le guide d’authentification l’appelle « Create new key ».
3. Donnez un nom identifiable, comme music-development.
4. Copiez la clé affichée dans le gestionnaire de secrets du serveur ou un fichier d’environnement local exclu du contrôle de version.^[1]

Définissez REAPI_API_KEY dans l’environnement du processus qui exécute l’exemple. C’est notre nom de variable, pas un champ obligatoire de l’API. Ne placez pas une vraie clé dans le code, un bundle navigateur, un dépôt, une URL ou un message d’assistance. Le préfixe de production documenté est rk_live_. rk_test_, avec réponses simulées, reste indiqué « coming soon » : ce n’est pas une voie de test gratuit disponible ici.^[1]

Comment faire un appel à l’API Suno via reAPI ?

Les quatre exemples envoient la même requête en mode inspiration. custom_mode: false fait de prompt une description de chanson ; instrumental: false demande du chant. L’opération se choisit dans model, la version de génération dans version. Utilisez les noms de champs actuels en snake_case.^[3]

Les 30 secondes représentent un délai réseau, pas une échéance de création de la chanson. La génération continue de façon asynchrone après l’envoi. Chaque exemple vérifie les erreurs HTTP et affiche l’identifiant de tâche. Ce sont des alternatives d’envoi ; effectuez ensuite le suivi.

cURL

Cette version emploie aussi jq pour extraire id. La variable d’environnement doit déjà contenir votre clé.

: "${REAPI_API_KEY:?Set REAPI_API_KEY in your environment}"
curl --fail-with-body --silent --show-error --max-time 30 \
  https://reapi.ai/api/v1/audio/generations \
  -H "Authorization: Bearer $REAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "suno-music",
    "version": "V6",
    "custom_mode": false,
    "instrumental": false,
    "prompt": "An upbeat acoustic song about taking the first train home"
  }' > suno-submit.json && jq -er '.id' suno-submit.json

Python

Installez requests si nécessaire. Enregistrez et exécutez le code sur le serveur ou dans votre terminal local.

import os
import requests

response = requests.post(
    "https://reapi.ai/api/v1/audio/generations",
    headers={"Authorization": f"Bearer {os.environ['REAPI_API_KEY']}"},
    json={
        "model": "suno-music",
        "version": "V6",
        "custom_mode": False,
        "instrumental": False,
        "prompt": "An upbeat acoustic song about taking the first train home",
    },
    timeout=30,
)
response.raise_for_status()
print(response.json()["id"])

Node.js

Enregistrez le fichier sous submit.mjs et lancez node submit.mjs avec la variable d’environnement définie.

const key = process.env.REAPI_API_KEY;
if (!key) throw new Error("Set REAPI_API_KEY in your environment");

const response = await fetch("https://reapi.ai/api/v1/audio/generations", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${key}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "suno-music",
    version: "V6",
    custom_mode: false,
    instrumental: false,
    prompt: "An upbeat acoustic song about taking the first train home",
  }),
  signal: AbortSignal.timeout(30_000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const task = await response.json();
if (!task.id) throw new Error("Submission response has no task id");
console.log(task.id);

Go

Enregistrez-le sous main.go et lancez go run main.go. L’exemple utilise uniquement la bibliothèque standard.

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "strings"
    "time"
)

func main() {
    if err := submit(); err != nil {
        log.Fatal(err)
    }
}

func submit() error {
    key := os.Getenv("REAPI_API_KEY")
    if key == "" {
        return fmt.Errorf("set REAPI_API_KEY in your environment")
    }
    payload := `{"model":"suno-music","version":"V6","custom_mode":false,"instrumental":false,"prompt":"An upbeat acoustic song about taking the first train home"}`
    req, err := http.NewRequest("POST",
        "https://reapi.ai/api/v1/audio/generations", strings.NewReader(payload))
    if err != nil {
        return err
    }
    req.Header.Set("Authorization", "Bearer "+key)
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{Timeout: 30 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return err
    }
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        return fmt.Errorf("HTTP %d: %s", resp.StatusCode, body)
    }
    var task struct { ID string `json:"id"` }
    if err := json.Unmarshal(body, &task); err != nil {
        return err
    }
    if task.ID == "" {
        return fmt.Errorf("submission response has no task id")
    }
    fmt.Println(task.ID)
    return nil
}

Conserver l’identifiant et attendre que l’audio soit prêt

La réponse d’envoi contient id, model, status et created_at. Le champ à conserver est id, même si le texte descriptif l’appelle identifiant de tâche. Ne tentez pas de lire un champ task_id de premier niveau absent de cette réponse.^[3]

Remplacez le texte indicatif par l’ID reçu. Cette commande effectue une seule vérification. Répétez-la environ toutes les trois secondes tant que le statut est processing, avec une limite d’attente côté client adaptée à l’application. La référence recommande d’espacer les consultations, qui ne consomment pas de crédits.^[4]

: "${REAPI_API_KEY:?Set REAPI_API_KEY in your environment}"
TASK_ID='replace-with-the-returned-id'
curl --fail-with-body --silent --show-error --max-time 30 \
  "https://reapi.ai/api/v1/tasks/$TASK_ID" \
  -H "Authorization: Bearer $REAPI_API_KEY"

Vérifiez le statut JSON en plus du statut HTTP :

• processing : conservez l’ID et attendez avant de consulter à nouveau.
• completed : lisez output.audio_urls et les enregistrements Suno tracks décrits dans la documentation.
• failed : arrêtez la boucle et examinez error.code, error.message et usage.credits.^[3][4]

La vérification en production de cette série s’est terminée avec deux URL audio. Elle valide un parcours de génération, pas un benchmark de latence ni le succès de toutes les requêtes. La référence Suno garantit url pour une piste ; les métadonnées comme l’ID, les paroles et la durée peuvent être absentes lorsqu’elles sont vides. Conservez les IDs retournés si des modifications ultérieures en ont besoin.^[3]

Si votre limite d’attente locale expire après réception de l’ID, vous pouvez reprendre le suivi de cette tâche plus tard. Ne soumettez pas immédiatement une nouvelle génération simplement parce que le client a cessé d’attendre. Pour une conservation durable, copiez l’audio terminé dans votre stockage : le contrat des tâches ne promet pas de rétention permanente sur le CDN.^[4]

Corriger les erreurs d’authentification, de solde et de paramètres

La référence distingue les erreurs HTTP des échecs de tâches. Une tâche trouvée peut renvoyer HTTP 200 avec status: "failed" et un code 8xxxx dans le JSON.^[5]

Conservez request_id lorsqu’il est fourni, ainsi que la méthode et l’heure approximative. Ces données facilitent l’enquête sans transmettre la clé. Corrigez les problèmes de validation, d’authentification ou de solde avant de réessayer.^[5]

Ce que signifient l’accès gratuit et la rotation des clés

Une clé authentifie les requêtes ; elle ne rend pas la génération gratuite. Un solde hypothétique de 0,10 USD représente 100 crédits. À 60 crédits par requête de chanson terminée, il couvre une requête et laisse 40 crédits, insuffisants pour une deuxième chanson complète. Vérifiez votre éligibilité promotionnelle et votre solde réel plutôt que de supposer une clé API Suno gratuite et illimitée.^[3]

Le guide des prix de Suno API détaille les frais de modification et d’export. Révoquez une clé exposée dans les paramètres. Pour une rotation normale, créez une remplaçante, mettez à jour le secret du serveur, vérifiez le nouvel identifiant, puis révoquez l’ancien. La documentation indique que les tâches déjà en attente continuent après révocation et peuvent encore débiter des crédits. La révocation bloque les nouvelles requêtes sans annuler ces tâches.^[1]

Questions fréquentes

Où obtenir une clé API Suno ?

Pour reAPI, utilisez les paramètres API Keys, qui créent un identifiant reAPI. Le formulaire officiel de Suno est une candidature de partenaire séparée.^[1][2]

L’abonnement Suno comprend-il cette clé ?

Non. L’abonnement Suno et le compte reAPI sont distincts. Utilisez un identifiant émis par le service dont vous appelez l’endpoint ; consultez l’explication de l’accès officiel.

Puis-je obtenir une clé gratuite pour générer sans limite ?

Un identifiant ne fournit pas un crédit illimité. Vérifiez le solde et le prix de l’opération. Le solde d’exemple de 0,10 USD finance une requête à 0,06 USD, pas une génération gratuite continue.^[3]

Comment authentifier un appel à l’API Suno sur reAPI ?

Envoyez Authorization: Bearer <key> pour le POST de génération et le GET de tâche. Gardez la clé sur le serveur, pas dans le prompt du corps JSON.^[1]

Pourquoi recevoir HTTP 200 sans chanson ?

L’envoi est asynchrone. Conservez id et interrogez la tâche jusqu’au statut JSON completed ou failed. Le suivi peut renvoyer HTTP 200 même si la tâche a échoué.^[4][5]

Ma clé change-t-elle avec V6 Mini ou Wild ?

L’authentification Bearer reste identique. Sélectionnez V6_MINI ou V6_WILD dans version pour une opération compatible ; ne remplacez pas model par le nom de version. Le guide d’intégration V6 précise les règles.^[3]

Terminez d’abord une requête

Une clé API Suno fonctionnelle est la première étape. Conservez l’ID, gérez les deux états finaux et sauvegardez l’audio d’une tâche terminée. Une fois ce petit parcours opérationnel, ajoutez des paroles personnalisées, d’autres variantes V6 ou des modifications selon la référence Suno, en tenant compte des paramètres et des tarifs.

Références

1. reAPI. Authentication and key management. Retrieved September 14, 2026 from Authentication; key-creation button also checked at API Keys.
2. Suno. Developer API partner-interest application. Retrieved September 14, 2026 from official application.
3. reAPI. Suno operation and version reference. Retrieved September 14, 2026 from Suno, Suno V6 and the public rate card.
4. reAPI. Task polling reference. Retrieved September 14, 2026 from Tasks.
5. reAPI. Error codes and handling. Retrieved September 14, 2026 from Errors.