Schnellstart

Diese Seite bringt Sie von null zu funktionierenden Aufrufen der StickyPrompts-REST-API. Jedes Beispiel gibt es in cURL, Python (requests) und JavaScript (fetch, ab Node 18). Derselbe Schlüssel funktioniert auch für den MCP-Server. Sobald Sie ihn haben, können Sie also auch Claude Code oder Cursor verbinden.

Alle REST-Pfade beziehen sich auf https://api.stickyprompts.com/api/v1.

Tutorial 12 von 14 · 1:53 The API Video auf Englisch, in der echten App aufgenommen

Tipp · 0:17 Ask a model from any script Video auf Englisch, in der echten App aufgenommen

1. API-Schlüssel erstellen

1. Settings > API keys öffnen

   Öffnen Sie in der App Settings und wählen Sie API keys. Die Seite zeigt beide Basis-URLs und genau den Header, den Sie senden müssen.

   app.stickyprompts.com/settings#api 1 Schlüssel erstellen 2 REST-Basis-URL 3 MCP-Endpunkt 4 Diesen Header senden

2. Schlüssel mit den nötigen Berechtigungen erzeugen

   Wählen Sie Generate key, geben Sie dem Schlüssel einen Namen (zum Beispiel Schnellstart) und haken Sie seine Berechtigungen an. Für diese Seite brauchen Sie:

   • ai_models_get - Modelle auflisten
   • custom_run - ein Modell direkt fragen
   • conversations_manage - Unterhaltungen starten und fortsetzen
   • prompts_get und run_prompt - gespeicherte Prompts finden und ausführen
3. Schlüssel sofort kopieren

   Der vollständige Schlüssel (STICKY-API- gefolgt von 64 Zeichen) wird nur einmal angezeigt. Kopieren Sie ihn direkt in Ihren Secret Store. Wenn Sie ihn verlieren, löschen Sie den Schlüssel und erzeugen Sie einen neuen.

2. Als Umgebungsvariable speichern

Halten Sie den Schlüssel aus Ihrem Code heraus. Alle folgenden Beispiele lesen ihn aus STICKY_API_KEY.

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

Jeder Request sendet ihn als Bearer-Token:

Authorization: Bearer STICKY-API-...

3. Verfügbare Modelle auflisten

Modelle werden über ihre numerische ID identifiziert, die andere Endpunkte als ai_model_id erwarten. Mit legacy=false blenden Sie veraltete Modelle aus. Verwenden Sie Modelle, bei denen selectable den Wert true hat. false bedeutet, dass die Regeln Ihres Workspace für Modellzugriff oder Datenresidenz das Modell für Sie sperren.

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

Die Antwort ist ein JSON-Array, hier auf die wichtigsten Felder gekürzt (die Werte sind Beispiele):

[
  {
    "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
  }
]

Achten Sie auf die gemischte Schreibweise: ID ist großgeschrieben, alles andere in snake_case. Dezimalwerte wie multiplier kommen als Strings an. Siehe Fehler, Paginierung und Kontingente.

4. Einem Modell eine Frage stellen

POST /run schickt einen Text an ein Modell und gibt dessen Antwort zurück. Es wird keine Unterhaltung gespeichert, und es kommen weder ein System-Prompt noch der Workspace-Prompt oder Projektanweisungen hinzu. Die Nutzung wird trotzdem erfasst.

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

Die Antwort ist ein nicht gespeichertes Nachrichtenobjekt (seine ID ist 0). Die Antwort des Modells steht in text, als unverarbeitetes Markdown:

{
  "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. Unterhaltung starten und nachfassen

Eine Unterhaltung wird gespeichert und erscheint in der App in Ihrer Chat History, genau wie ein dort gestarteter Chat. POST /conversation legt sie an, sendet die erste Nachricht und wartet auf die vollständige Antwort. Geben Sie immer ein Modell an: entweder ai_model_id oder auto_model_type (best, balanced oder cheapest), damit StickyPrompts für jede Nachricht das beste Modell für die Aufgabe wählt.

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

Die Antwort ist die fertige KI-Nachricht. Ihre conversation_context_id ist die ID der neuen Unterhaltung (gekürzt):

{
  "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": []
}

Eine Folgenachricht in derselben Unterhaltung senden Sie mit POST /conversation/{id}. Folgenachrichten nehmen nur die Nachricht entgegen (und optional Anhänge, Wissensdatenbanken und Tools). Die Unterhaltung behält ihr Modell.

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

Die Antwort hat denselben Aufbau wie jede Nachricht. Für lange Antworten können Sie stattdessen POST /conversation/stream verwenden: Der Endpunkt gibt sofort die ID der Unterhaltung zurück und liefert die Antwort über einen WebSocket. Siehe Unterhaltungen und Nachrichten.

6. Gespeicherten Prompt mit Variablen ausführen

Gespeicherte Prompts enthalten {{variables}}. Dieser Endpunkt füllt sie aus und führt den Prompt in einem einzigen Aufruf aus, mit dem Modell und dem Antwortstil des Prompts. Dabei entsteht eine neue Unterhaltung.

Sie brauchen zwei Arten von IDs:

• Die Prompt-ID. Listen Sie Ihre Prompts mit GET /prompt auf (Berechtigung prompts_get) und lesen Sie die ID jedes Prompts aus.
• Die Variablen-IDs. Jeder Eintrag in variable_values benennt eine Variable über ihre numerische variable_id. Ein API-Schlüssel kann keinen einzelnen Prompt samt Variablen lesen (GET /prompt/:id ist für Schlüssel nicht freigegeben). Entnehmen Sie die IDs deshalb einer dieser Quellen: dem Ausführungsverlauf des Prompts (GET /prompt/:id/run_history listet für jede Ausführung die Variablen mit variable_id, slug und value), einer Instanz (GET /instance/:id) oder der Antwort von POST /variable, falls Sie die Variable über die API angelegt haben. Schlagen Sie die IDs einmal nach und legen Sie sie in Ihrer Konfiguration ab. Siehe Prompts und Ausführungen.

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

Variablen, die Sie weglassen oder leer senden, erhalten ihren Standardwert. Die Antwort ist ein einzelnes Ausführungsobjekt (gekürzt):

{
  "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"
}

Drei Dinge sollten Sie wissen:

• result ist HTML, gerendert aus dem Markdown des Modells. Das unverarbeitete Markdown erhalten Sie, wenn Sie die Unterhaltung mit GET /conversation/16044 lesen.
• Ein Ausfall beim Anbieter liefert trotzdem 200, mit run_status: "error" und gesetztem error_text / error_id. Prüfen Sie run_status.
• Wenn Sie nur eine Eingabe ändern müssen, wiederholt POST /run/prompt/:id mit {"data": "..."} die letzte Ausführung des Prompts mit neuem Text in seiner primären Variable. Variablen-IDs brauchen Sie dafür nicht.

Nächste Schritte