Démarrage rapide

Cette page vous emmène de zéro à des appels fonctionnels vers l’API REST de StickyPrompts. Chaque exemple est fourni en cURL, en Python (requests) et en JavaScript (fetch, Node 18 ou version ultérieure). La même clé fonctionne aussi avec le serveur MCP : une fois que vous l’avez, vous pouvez également connecter Claude Code ou Cursor.

Tous les chemins REST sont relatifs à https://api.stickyprompts.com/api/v1.

Tutoriel 12 sur 14 · 1:53 The API Vidéo en anglais, enregistrée dans l'application réelle

Astuce · 0:17 Ask a model from any script Vidéo en anglais, enregistrée dans l'application réelle

1. Créer une clé API

1. Ouvrir Settings > API keys

   Dans l’application, accédez à Settings et sélectionnez API keys. La page affiche les deux URL de base et le header exact à envoyer.

   app.stickyprompts.com/settings#api 1 Créer une clé 2 URL de base REST 3 Endpoint MCP 4 Envoyez ce header

2. Générer une clé avec les autorisations nécessaires

   Sélectionnez Generate key, donnez un nom à la clé (par exemple Quickstart) et cochez ses autorisations. Pour cette page, il vous faut :

   • ai_models_get - lister les modèles
   • custom_run - interroger directement un modèle
   • conversations_manage - démarrer et poursuivre des conversations
   • prompts_get et run_prompt - trouver et exécuter des prompts enregistrés
3. Copier la clé tout de suite

   La clé complète (STICKY-API- suivi de 64 caractères) ne s’affiche qu’une seule fois. Copiez-la directement dans votre coffre de secrets. Si vous la perdez, supprimez la clé et générez-en une nouvelle.

2. La stocker dans une variable d’environnement

Gardez la clé hors de votre code. Tous les exemples ci-dessous la lisent dans STICKY_API_KEY.

export STICKY_API_KEY="STICKY-API-..."

Chaque requête l’envoie comme token bearer :

Authorization: Bearer STICKY-API-...

3. Lister les modèles disponibles

Les modèles sont identifiés par leur ID numérique, que les autres endpoints attendent sous le nom ai_model_id. Ajoutez legacy=false pour masquer les modèles obsolètes, et utilisez les modèles dont selectable vaut true : false signifie que les règles d’accès aux modèles ou de résidence des données de votre espace de travail vous en bloquent l’usage.

curl "https://api.stickyprompts.com/api/v1/ai_model?legacy=false" \
  -H "Authorization: Bearer $STICKY_API_KEY"

import os
import requests

BASE = "https://api.stickyprompts.com/api/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['STICKY_API_KEY']}"}

r = requests.get(f"{BASE}/ai_model", params={"legacy": "false"}, headers=HEADERS)
r.raise_for_status()
for m in r.json():
    if m["selectable"]:
        print(m["ID"], m["name"], m["powered_by"])

const BASE = "https://api.stickyprompts.com/api/v1";
const headers = { Authorization: `Bearer ${process.env.STICKY_API_KEY}` };

const res = await fetch(`${BASE}/ai_model?legacy=false`, { headers });
if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
for (const m of await res.json()) {
  if (m.selectable) console.log(m.ID, m.name, m.powered_by);
}

La réponse est un tableau JSON, réduit ici aux champs les plus utiles (les valeurs sont données à titre d’exemple) :

[
  {
    "ID": 42,
    "name": "Claude Sonnet 5",
    "powered_by": "Anthropic",
    "description": "Balanced model for everyday work.",
    "flagship": true,
    "deprecated": false,
    "thinking_model": true,
    "reasoning_efforts": ["low", "medium", "high"],
    "tools": ["file_upload", "web_search", "remote_mcp"],
    "multiplier": "1",
    "stream_support": true,
    "selectable": true
  }
]

Remarquez la casse mixte : ID est en majuscules, tout le reste en snake_case. Les valeurs décimales comme multiplier arrivent sous forme de chaînes. Voir Erreurs, pagination et quotas.

4. Poser une question à un modèle

POST /run envoie un texte à un modèle et renvoie sa réponse. Rien n’est enregistré sous forme de conversation, et aucun prompt système, prompt d’espace de travail ni instruction de projet n’est ajouté. L’utilisation est tout de même enregistrée.

curl -X POST https://api.stickyprompts.com/api/v1/run \
  -H "Authorization: Bearer $STICKY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Write a one-line tagline for Northwind Analytics.", "ai_model_id": 42}'

r = requests.post(
    f"{BASE}/run",
    headers=HEADERS,
    json={"prompt": "Write a one-line tagline for Northwind Analytics.", "ai_model_id": 42},
)
r.raise_for_status()
print(r.json()["text"])

const res = await fetch(`${BASE}/run`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({
    prompt: "Write a one-line tagline for Northwind Analytics.",
    ai_model_id: 42,
  }),
});
if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
console.log((await res.json()).text);

La réponse est un objet message non enregistré (son ID vaut 0). La réponse du modèle se trouve dans text, en Markdown brut :

{
  "ID": 0,
  "ai_model_id": 42,
  "text": "Northwind Analytics: see what sells before it sells out.",
  "isUser": false,
  "status": "finished",
  "ai_style": "prompty",
  "error_text": null,
  "error_id": null
}

5. Démarrer une conversation et envoyer un message de suivi

Une conversation est enregistrée et apparaît dans votre Chat History dans l’application, comme un chat que vous y auriez démarré. POST /conversation la crée, envoie le premier message et attend la réponse complète. Indiquez toujours un modèle : soit ai_model_id, soit auto_model_type (best, balanced ou cheapest) pour laisser StickyPrompts choisir le meilleur modèle pour chaque message.

curl -X POST https://api.stickyprompts.com/api/v1/conversation \
  -H "Authorization: Bearer $STICKY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Draft three subject lines for the Northwind Q4 newsletter.",
    "ai_model_id": 42
  }'

r = requests.post(
    f"{BASE}/conversation",
    headers=HEADERS,
    json={
        "message": "Draft three subject lines for the Northwind Q4 newsletter.",
        "ai_model_id": 42,
    },
)
r.raise_for_status()
reply = r.json()
conversation_id = reply["conversation_context_id"]
print(reply["raw_text"])

const res = await fetch(`${BASE}/conversation`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({
    message: "Draft three subject lines for the Northwind Q4 newsletter.",
    ai_model_id: 42,
  }),
});
if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
const reply = await res.json();
const conversationId = reply.conversation_context_id;
console.log(reply.raw_text);

La réponse est le message final de l’IA. Son conversation_context_id est l’identifiant de la nouvelle conversation (extrait) :

{
  "ID": 90412,
  "CreatedAt": "2026-09-28T09:14:03.512Z",
  "conversation_context_id": 5120,
  "ai_model_id": 42,
  "is_auto_model": false,
  "text": "Here are three options for the subject line: ...",
  "raw_text": "Here are three options for the subject line: ...",
  "isUser": false,
  "status": "finished",
  "error_text": null,
  "error_id": null,
  "response_duration_ms": 6210,
  "attachments": []
}

Envoyez un message de suivi dans la même conversation avec POST /conversation/{id}. Les messages de suivi n’acceptent que le message (avec, en option, des pièces jointes, des bases de connaissances et des outils) ; la conversation conserve son modèle.

curl -X POST https://api.stickyprompts.com/api/v1/conversation/5120 \
  -H "Authorization: Bearer $STICKY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"message": "Make the second one shorter and more playful."}'

r = requests.post(
    f"{BASE}/conversation/{conversation_id}",
    headers=HEADERS,
    json={"message": "Make the second one shorter and more playful."},
)
r.raise_for_status()
print(r.json()["raw_text"])

const res2 = await fetch(`${BASE}/conversation/${conversationId}`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({ message: "Make the second one shorter and more playful." }),
});
if (!res2.ok) throw new Error(`${res2.status} ${await res2.text()}`);
console.log((await res2.json()).raw_text);

La réponse a la même forme de message. Pour les réponses longues, vous pouvez utiliser POST /conversation/stream à la place : cet endpoint renvoie immédiatement l’identifiant de la conversation et transmet la réponse sur un WebSocket (voir Conversations et messages).

6. Exécuter un prompt enregistré avec des variables

Les prompts enregistrés contiennent des {{variables}}. Cet endpoint les remplit et exécute le prompt en un seul appel, avec le modèle et le style de réponse propres au prompt. Il crée une nouvelle conversation.

Il vous faut deux types d’identifiants :

• L’identifiant du prompt. Listez vos prompts avec GET /prompt (autorisation prompts_get) et relevez l’ID de chacun.
• Les identifiants des variables. Chaque élément de variable_values désigne une variable par son variable_id numérique. Une clé API ne peut pas lire un prompt individuel avec ses variables (GET /prompt/:id n’est pas accessible aux clés) : récupérez donc les identifiants à l’une de ces sources : l’historique d’exécution du prompt (GET /prompt/:id/run_history liste les variables de chaque exécution avec variable_id, slug et value), une instance (GET /instance/:id) ou la réponse de POST /variable si vous avez créé la variable via l’API. Recherchez-les une fois et conservez-les dans votre configuration. Voir Prompts et exécutions.

curl -X POST https://api.stickyprompts.com/api/v1/run/prompt/42/variables \
  -H "Authorization: Bearer $STICKY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "variable_values": [
      {"variable_id": 301, "value": "Bluebird Market"},
      {"variable_id": 302, "value": "Growth plan renewal"}
    ]
  }'

r = requests.post(
    f"{BASE}/run/prompt/42/variables",
    headers=HEADERS,
    json={
        "variable_values": [
            {"variable_id": 301, "value": "Bluebird Market"},
            {"variable_id": 302, "value": "Growth plan renewal"},
        ]
    },
)
r.raise_for_status()
run = r.json()
print(run["run_status"], run["result"])

const res3 = await fetch(`${BASE}/run/prompt/42/variables`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({
    variable_values: [
      { variable_id: 301, value: "Bluebird Market" },
      { variable_id: 302, value: "Growth plan renewal" },
    ],
  }),
});
if (!res3.ok) throw new Error(`${res3.status} ${await res3.text()}`);
const run = await res3.json();
console.log(run.run_status, run.result);

Les variables que vous omettez, ou que vous envoyez vides, prennent leur valeur par défaut. La réponse est un objet d’exécution unique (extrait) :

{
  "id": 7781,
  "created_at": "2026-09-28T09:12:03Z",
  "result": "<p>Hi Sarah, it has been a great year with Bluebird Market ...</p>\n",
  "raw_text": null,
  "runtime": 4210,
  "ai_model_id": 42,
  "conversation_context_id": 16044,
  "conversation_context_slug": "q8w2m1zc",
  "error_text": null,
  "error_id": null,
  "run_status": "success"
}

Trois points à retenir :

• result est du HTML généré à partir du Markdown du modèle. Pour obtenir le Markdown brut, lisez la conversation avec GET /conversation/16044.
• Une défaillance du fournisseur renvoie tout de même 200, avec run_status: "error" et error_text / error_id renseignés. Vérifiez run_status.
• Si vous n’avez qu’une seule entrée à changer, POST /run/prompt/:id avec {"data": "..."} rejoue la dernière exécution du prompt avec un nouveau texte dans sa variable principale, sans avoir besoin d’identifiants de variables.

Étapes suivantes