Nutze freigegebene Anbietermodelle mit eigener Euro-Abrechnung. Verwalte den Verlauf selbst oder ergänze mit einer Endnutzerkennung Brain, Dateien und Erinnerungen. Antworten sind synchron, als Stream und im Hintergrund verfügbar.
Für FlowModels ist kein FlowSuite-Abonnement erforderlich. Du zahlst nach Verbrauch und benötigen Guthaben oder einen freigeschalteten Kreditrahmen. Erstelle im FlowModels-Dashboard einen Schlüssel mit der Berechtigung „KI nutzen“ (kind: inference). „Schlüssel verwalten“ erlaubt nur die Verwaltung von API-Schlüsseln. Halte geheime Schlüssel in deinem eigenen Backend.
Die passende Schnittstelle
FlowModels ist eine OpenAI-kompatible Schnittstelle mit eigenen API-Schlüsseln und Abrechnung nach Verbrauch in Euro. Ein FlowModels-Schlüssel ist fest diesem Produkt und einem Abrechnungsteam zugeordnet; external_identifier aktiviert optional Brain-Kontext und wechselt nicht das Abrechnungsprodukt. Schlüssel aus einem FlowSuite-Abonnement sind davon getrennt: Die Modellaufrufe dieser Schnittstelle lehnen sie mit 403 insufficient_key_scope ab.
Erste Anfrage vorbereiten
Öffne das FlowModels-Dashboard und erstelle dort einen Schlüssel mit „KI nutzen“. Team-Inhaber haben Zugriff; andere Mitglieder benötigen die eigene FlowModels-Freigabe. Bei der API-basierten Schlüsselerstellung muss kind: inference ausdrücklich gesetzt werden; ohne Angabe entsteht ein Schlüssel mit „Schlüssel verwalten“ (kind: management).
Lade im Prepaid-Modus mindestens 20 € Guthaben auf oder verwende eine ausdrücklich freigegebene Postpaid-Kreditlinie.
Frage GET /models ab und wähle eine vollständige Modellkennung.
Sende model und deine Nachrichten, optional ergänzt um external_identifier, über einen der beiden folgenden Endpunkte für KI-Anfragen.
Wenn du Brain verwendest, speichere conversation aus der Antwort. Ohne Brain sende den benötigten Verlauf selbst mit.
Wo diese API bewusst von OpenAI abweicht
Für Chat Completions und Responses kann ein bestehender OpenAI-Client grundsätzlich die FlowModels-Basisadresse verwenden. Beachte dabei die folgenden Unterschiede. Die Datei- und Live-Transkription hat einen eigenen Vertrag mit Aufträgen, Sitzungen und Verbindungstickets.
Abbrechen ist auf jedem Endzustand ein erfolgreicher Nichtvorgang.POST /responses/{response_uuid}/cancel antwortet auch dann mit dem Zustand der Antwort, wenn diese längst abgeschlossen, fehlgeschlagen oder bereits abgebrochen ist. Der Aufruf ist damit ohne Idempotenzschlüssel wiederholbar; das Ergebnis hängt am Zustand des Auftrags, nicht an der Zahl der Aufrufe.
Eine abgebrochene Verbindung setzt nichts fort. Reisst die Verbindung während einer synchronen oder gestreamten Anfrage ab, gibt es keine Fortsetzungsmarke: die Anfrage wird neu gestartet und erneut abgerechnet. Bereits entstandene Kosten bleiben bestehen. Nur ein gespeicherter Hintergrundauftrag lässt sich weiter beobachten, über starting_after, und dieser Abruf startet keinen neuen Modellaufruf.
Die Verlaufsverdichtung ist opt-in. Passt der selbst gesendete Verlauf nicht in das Eingabefenster, wird die Anfrage mit 400 context_length_exceeded abgelehnt statt stillschweigend gekürzt. Mit context_compression: true erlaubst du die Zusammenfassung ausdrücklich; sie ist ein zusätzlicher kostenpflichtiger Modellaufruf und wird in usage.flowai.compression einzeln ausgewiesen.
Die Websuche ist standardmässig aus.web_search schaltet die native Suche des Anbieters ein und wird zusätzlich abgerechnet. Ein Modell, dessen Suche fest eingebaut ist, lehnt umgekehrt false ab, statt die bezahlte Suche heimlich doch auszuführen.
Die Suche lässt sich auf Domains eingrenzen, und die Quellen kommen mit.search_domain_filter nimmt eine Liste wie ["firma.de"] (nur diese Domains) oder ["-reddit.com"] (diese Domains nicht) und schaltet die Suche ein. Hat das Modell gesucht, enthält die Antwort citations mit den Adressen und search_results mit title, url und date je Quelle, bei Chat-Completions im letzten Chunk eines Streams. Ohne Suche fehlen beide Felder.
Ohne Angabe gilt das Modellmaximum an Ausgabetokens. Es wird kein stiller Standardwert eingesetzt, und eine Angabe über dem Maximum des Modells wird mit 400 invalid_field_value und der Nennung dieses Maximums abgelehnt, statt gekürzt zu werden.
Dateien gehen an das gewählte Modell, nicht ins Brain. Chat Completions und Responses nehmen file_id aus POST /files, Direktbytes und https-URLs an. Bilder und Videos sieht nur ein Modell, das den Typ führt, sonst 400 unsupported_for_model. Dokumente, die das Modell nicht selbst liest, werden als Text extrahiert. Audio, das das Modell nicht selbst hört, wird vorher transkribiert und separat abgerechnet. Endnutzerdateien unter /end_users bleiben Textdokumente. Direktbytes sind auf 8 MiB je Anfrage begrenzt. Liegt die Proxy-Grenze darunter, bleiben file_id und URL nutzbar.
Authentifizierung
Verwende ausschließlich Authorization: Bearer $FLOWMODELS_API_KEY. Weder die Endnutzerkennung noch die Modellwahl ersetzt die Authentifizierung. JSON-Anfragen benötigen Content-Type: application/json. Alle Pfade auf dieser Seite sind relativ zur Basis-URL oben. Nur die Schlüsselverwaltung unter /api/user/api-keys liegt nicht unter dieser Basis-URL, sondern auf creativeskyline.de; ihre Beispiele nennen die vollständige Adresse.
Modelle
Konkretes Modell auswählen
GET /models liefert mit deinem FlowModels-Schlüssel ausschließlich freigegebene, bepreiste Anbietermodelle. Wähle einen Eintrag mit vollständiger Kennung im Format provider/model-id. Übernimm dessen id unverändert als model.
Die Beispiele verwenden groq/openai/gpt-oss-120b als Muster. Prüfe vor der Nutzung, ob diese Kennung in deiner aktuellen Modellliste enthalten ist, und ersetze sie gegebenenfalls. Verfügbarkeit, Kontextgrenzen und unterstützte Dateiformate hängen vom Modell ab.
Die Preise stehen unter pricing.prompt und pricing.completion als Eurobetrag je einer Million Tokens, mit pricing.currency: EUR und pricing.unit: per_million_tokens. Die API liefert genaue Dezimalzeichenfolgen; die Modellübersicht rundet die Anzeige auf zwei Nachkommastellen. Diese Anzeigerundung verändert die Abrechnung nicht. Die Preise enthalten die für dein Team geltende Marge. Die Modellübersicht im FlowModels-Dashboard verwendet dieselbe Preisquelle. Die Liste ist paginiert: Verwende bei has_more: true den Wert aus last_id als after. Die Modellkennung kann selbst weitere Schrägstriche enthalten.
Transkriptionsmodelle besitzen stattdessen transcription für Fähigkeiten und Grenzen sowie pricing.unit: per_minute und pricing.variants für die bepreisten Betriebsarten und Optionen. Diese Modelle werden über die Audio-Endpunkte aufgerufen. Audio- und Text-Tokenpreise können zusätzlich ausgewiesen sein, wenn der Anbieter anhand tatsächlicher Tokens abrechnet.
Videomodelle (kindvideo) besitzen stattdessen video für Modus, Dauer, Auflösungen und Optionen sowie pricing.unit: per_second und pricing.variants für die bepreisten Kombinationen aus Auflösung, Ton und enable_thinking. Diese Modelle werden über die Video-Endpunkte aufgerufen.
Bildmodelle (kindimage) besitzen stattdessen image für Größen, Qualitäten und Bearbeitung sowie pricing.unit: per_image und pricing.variants für die bepreisten Kombinationen aus Größe und Qualität. Jede Variante nennt per_image, den Preis einer Erzeugung. Kann das Modell bearbeiten (image.edits), steht dort zusätzlich per_image_edit, der Preis einer Bearbeitung über POST /images/edits, der wegen des Referenzbilds höher liegen kann. Diese Modelle werden über die Bild-Endpunkte aufgerufen.
Was ein Modelleintrag aussagt
kind sagt, wofür das Modell gedacht ist: chat, embedding, image, video, audio, realtime oder other. Chat Completions und Responses nehmen ausschließlich Modelle mit kindchat an; jedes andere Modell wird mit 400 unsupported_for_model und parammodel abgelehnt, bevor Guthaben reserviert wird. Für Nicht-Chat-Modelle stehen alle Merkmale unter capabilities auf false.
context_length ist das Kontextfenster des Anbieters, flowai_limits.input_tokens dagegen die Grenze, die FlowModels tatsächlich zulässt. Die beiden Werte können abweichen; maßgeblich für deine Anfrage ist der kleinere aus flowai_limits. Ein Wert null bedeutet, dass keine Quelle eine Angabe macht, und niemals „unbegrenzt“.
data_residency nennt, wo der Anbieter die Anfrage verarbeitet. eu heißt, dass das Modell in einem Rechenzentrum in der Europäischen Union betrieben wird, derzeit die Modelle mit dem Präfix ionos/ (gehostet in Berlin). null heißt, dass keine solche Zusage gemacht wird.
supported_parameters nennt die Anfragefelder, die dieses Modell wirklich auswertet, in der Schreibweise dieser API. Ein Feld, das dort fehlt, wird mit 400 unsupported_for_model abgelehnt statt stillschweigend verworfen. capabilities beschreibt dieselbe Auskunft als Merkmale, etwa ob Reasoning, Websuche oder ein natives JSON-Schema zur Verfügung stehen; web_search_domain_filter_max nennt, wie viele Domains search_domain_filter annimmt, 0 heißt ohne Domainfilter. Die Rohangaben des Anbieters stehen unverändert unter provider_metadata; sie sind je Anbieter unterschiedlich aufgebaut und ausdrücklich keine Zusicherung.
GET /models/{model_id} liefert denselben Eintrag einzeln. Die Kennung wird unverändert übernommen, einschließlich enthaltener Schrägstriche. Unbekannte Kennungen und Modelle ohne gepflegten Preis beantworten beide 404 model_not_found.
Du wählst das Modell, nicht FlowModels
Mit model nennst du genau ein Modell und damit genau einen Anbieter. FlowModels trifft keine eigene Modellwahl: Es gibt keine automatische Lastverteilung und keinen automatischen Wechsel zu einem anderen Modell oder Anbieter. Antwortet der gewählte Anbieter nicht oder lehnt er ab, erhältst du den Fehler und entscheidest selbst, ob und mit welchem Modell du es erneut versuchst.
GET
/v1/models
Modelle auflisten
Listet die für deinen Schlüssel freigegebenen, bepreisten Anbietermodelle auf. Der Cursor ist jeweils die vollständige Modellkennung.
POST /embeddings erzeugt Vektoren für eigene Texte. Verwendbar sind ausschließlich die dafür freigegebenen Embedding-Modelle, derzeit openai/text-embedding-3-small, openai/text-embedding-3-large sowie die in der EU gehosteten Modelle ionos/BAAI/bge-m3 und ionos/Qwen/Qwen3-VL-Embedding-8B. Ein Sprachmodell wird mit 400 unsupported_for_model abgelehnt, bevor Guthaben reserviert wird.
Vektorlänge
dimensions ist optional. ionos/BAAI/bge-m3 liefert immer 1.024 Werte; angenommen wird dort nur 1024. ionos/Qwen/Qwen3-VL-Embedding-8B liefert ohne Angabe 4.096 Werte und kürzt auf jede Länge von 1 bis 4.096. Ein Wert, den das Modell nicht unterstützt, wird mit 400 unsupported_for_model und paramdimensions abgelehnt, bevor Guthaben reserviert wird. Bei den OpenAI-Modellen entscheidet der Anbieter über die zulässige Länge.
Eine Eingabe oder viele
input ist entweder eine Zeichenfolge oder eine Liste von Zeichenfolgen. Ein Stapel umfasst höchstens 2.048 Einträge mit je höchstens 8.192 Zeichen; überschreitest du eine der beiden Grenzen, wird die Anfrage abgelehnt und nicht gekürzt. Der gesamte Stapel wird in einem Anbieteraufruf verarbeitet und einmal abgerechnet. Die Reihenfolge der Antwort entspricht der Reihenfolge deiner Eingabe; index nennt sie zusätzlich.
Zahlenliste oder Base64
Ohne Angabe erhältst du die Vektoren als Zahlenliste. Mit encoding_format: base64 erhältst du stattdessen die Base64-Darstellung der Werte als 32-Bit-Gleitkommazahlen in Little-Endian-Reihenfolge. Das ist das Format, das die OpenAI-SDKs erwarten, und es überträgt deutlich weniger Bytes. usage.cost und usage.currency weisen den Endkundenbetrag in Euro aus, wie bei jeder anderen kostenpflichtigen Anfrage.
POST
/v1/embeddings
Vektoren erzeugen
Erzeugt Einbettungsvektoren für eine Zeichenfolge oder einen Stapel von Zeichenfolgen.
Request Body
modelstring
erforderlich
Kennung eines freigegebenen Embedding-Modells im Format provider/model-id
inputstring|array
erforderlich
Eine Zeichenfolge oder bis zu 2.048 Zeichenfolgen mit je höchstens 8.192 Zeichen
encoding_formatstring
float (Standard) oder base64 für Little-Endian-Float32
dimensionsinteger
Gewünschte Vektorlänge, sofern das Modell sie unterstützt: bge-m3 nur 1024, Qwen3-VL-Embedding-8B 1 bis 4096
userstring
Eigene Kennung des aufrufenden Endnutzers zur Missbrauchsnachverfolgung
POST /rerank bewertet, wie gut jedes deiner Dokumente zu einer Anfrage passt, und liefert die Dokumente nach Relevanz geordnet zurück, das relevanteste zuerst. Typischer Einsatz ist der zweite Schritt einer Suche: Eine Vektorsuche mit POST /embeddings liefert Kandidaten, Rerank ordnet sie genauer. Verwendbar ist ausschließlich das dafür freigegebene, in der EU gehostete Modell ionos/Qwen/Qwen3-VL-Reranker-8B. Jedes andere Modell wird mit 400 unsupported_for_model abgelehnt, bevor Guthaben reserviert wird. GET /models führt es als kind: rerank.
Anfrage und Grenzen
query ist eine nicht leere Zeichenfolge mit höchstens 8.192 Zeichen, documents eine Liste von 1 bis 1.000 nicht leeren Zeichenfolgen mit je höchstens 32.768 Zeichen und zusammen höchstens 1.000.000 Zeichen. Das Modell bewertet jedes Paar aus Anfrage und Dokument in einem Fenster von 32.768 Tokens. Überschreitest du eine Grenze, wird die Anfrage mit 400 invalid_field_value abgelehnt und nicht gekürzt; param nennt das Feld. Bilder und andere Inhaltsteile sind in query und documents derzeit nicht vorgesehen.
Antwort
results enthält je Dokument einen Eintrag mit index, der Position in deiner Liste documents, und relevance_score, absteigend sortiert. Mit top_n erhältst du nur die besten Einträge; 0 oder keine Angabe liefert alle. Ein Wert über der Anzahl deiner Dokumente wird mit 400 invalid_field_value abgelehnt. Mit return_documents: true enthält jeder Eintrag zusätzlich document.text mit deinem Dokument. model nennt die Kennung, die du gesendet hast.
Kosten
Abgerechnet werden nur Input-Tokens zum Preis je Token wie im Katalog, Output ist kostenlos. Weil das Modell jedes Dokument einzeln mit der Anfrage bewertet, zählt die Anfrage einmal je Dokument, dazu kommt je Paar eine feste Vorlage von etwa 66 Tokens. usage.prompt_tokens nennt die abgerechneten Tokens, usage.cost und usage.currency den Endkundenbetrag in Euro. Vor dem Aufruf wird eine Obergrenze reserviert, abgebucht wird der tatsächliche Verbrauch.
Fehlercodes
400 invalid_field_value: Der Body verletzt eine Grenze oder ein Format, siehe param.
400 unsupported_for_model: Das Modell ist kein freigegebenes Rerank-Modell.
429 insufficient_quota: Guthaben oder Ausgabenlimit reicht nicht aus.
503 provider_overloaded: Der Anbieter ist ausgelastet, warte die Sekunden aus Retry-After. Das Guthaben wurde nicht belastet.
500 rerank_failed: Die Dokumente konnten nicht bewertet werden.
POST
/v1/rerank
Dokumente bewerten
Bewertet Dokumente nach ihrer Relevanz für eine Anfrage und liefert sie absteigend sortiert.
Request Body
modelstring
erforderlich
Kennung eines freigegebenen Rerank-Modells im Format provider/model-id, derzeit ionos/Qwen/Qwen3-VL-Reranker-8B
querystring
erforderlich
Die Anfrage, nicht leer, höchstens 8.192 Zeichen
documentsarray
erforderlich
1 bis 1.000 nicht leere Zeichenfolgen mit je höchstens 32.768 Zeichen, zusammen höchstens 1.000.000 Zeichen
top_ninteger
Anzahl der besten Ergebnisse, höchstens die Anzahl der Dokumente; 0 oder keine Angabe liefert alle
return_documentsboolean
true fügt jedem Ergebnis document.text mit dem Dokument hinzu (Standard false)
curl -X POST "https://api.flowmodels.one/v1/rerank" \
-H "Authorization: Bearer $FLOWMODELS_API_KEY" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-d '{"model": "ionos/Qwen/Qwen3-VL-Reranker-8B", "query": "Was ist die Hauptstadt von Deutschland?", "documents": ["Paris ist die Hauptstadt Frankreichs.","Berlin ist die Hauptstadt Deutschlands."], "top_n": 1, "return_documents": true}'
import os
import requests
headers = {
'Authorization': f'Bearer {os.environ["FLOWMODELS_API_KEY"]}',
'Accept': 'application/json',
}
payload = {
'model': "ionos/Qwen/Qwen3-VL-Reranker-8B",
'query': "Was ist die Hauptstadt von Deutschland?",
'documents': ["Paris ist die Hauptstadt Frankreichs.", "Berlin ist die Hauptstadt Deutschlands."],
'top_n': 1,
'return_documents': True,
}
response = requests.post(
'https://api.flowmodels.one/v1/rerank',
headers=headers,
json=payload,
)
data = response.json()
const response = await fetch('https://api.flowmodels.one/v1/rerank', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.FLOWMODELS_API_KEY}`,
'Accept': 'application/json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: "ionos/Qwen/Qwen3-VL-Reranker-8B",
query: "Was ist die Hauptstadt von Deutschland?",
documents: ["Paris ist die Hauptstadt Frankreichs.","Berlin ist die Hauptstadt Deutschlands."],
top_n: 1,
return_documents: true,
}),
});
const data = await response.json();
use Illuminate\Support\Facades\Http;
$response = Http::withToken(getenv('FLOWMODELS_API_KEY'))
->post('https://api.flowmodels.one/v1/rerank', [
'model' => 'ionos/Qwen/Qwen3-VL-Reranker-8B',
'query' => 'Was ist die Hauptstadt von Deutschland?',
'documents' => array (
0 => 'Paris ist die Hauptstadt Frankreichs.',
1 => 'Berlin ist die Hauptstadt Deutschlands.',
),
'top_n' => 1,
'return_documents' => true,
]);
$data = $response->json();
Dateien und Live-Audio verwenden eigene Endpunkte. Jedes Transkript enthält text, bei Stille auch eine leere Zeichenfolge. timestamps ist standardmäßig deaktiviert; Zeitstempel erscheinen nur auf ausdrücklichen Wunsch in segments. Eine Sprecherzuordnung bietet derzeit kein Modell an, diarize=true wird deshalb abgelehnt. Nicht unterstützte Optionen und Sprachcodes werden vor dem kostenpflichtigen Anbieteraufruf mit HTTP 422 abgelehnt.
Modell
Datei
Live
Zusatzinformationen
groq/whisper-large-v3-turbo
Ja
Nein
Zeitstempel
groq/whisper-large-v3
Ja
Nein
Zeitstempel
openai/gpt-transcribe
Ja
Nein
Text
ionos/openai/whisper-large-v3
Ja
Nein
Zeitstempel, EU-gehostet (Berlin)
openai/gpt-live-transcribe
Nein
Ja
Text
Datei- und Live-Transkription werden getrennt freigeschaltet. Verwende nur Modelle aus deiner aktuellen Antwort von GET /models. Dort beschreiben transcription.modes, transcription.languages und die Optionsfelder die Fähigkeiten. pricing.variants enthält die verfügbaren Kombinationen aus Betriebsart und Zeitstempeln, mit Preisen in EUR je Minute und gegebenenfalls je einer Million Audio- oder Text-Tokens. Ein fehlender Preis verhindert den Start; es gibt keinen automatischen Anbieterwechsel.
Dateien und Hintergrundaufträge
Sende die Datei als multipart/form-data direkt an POST /audio/transcriptions. Eine zuvor hochgeladene file_id wird hier nicht angenommen. Die Beispiele im Codebereich starten einen Hintergrundauftrag. Lass background weg oder setze es auf false, wenn du synchron arbeiten möchtest. Überlasse dem HTTP-Client den Multipart-Header einschließlich seiner Boundary.
Synchron: höchstens 24 MiB und zehn Minuten, HTTP 200 mit Ergebnis.
Im Hintergrund:background=true, grundsätzlich höchstens 200 MiB und acht Stunden, HTTP 202 mit Auftrags-ID. Modellgrenzen gelten zusätzlich.
Frage GET /audio/transcriptions/{id} ab, bis status den Wert completed, cancelled oder failed hat. Davor sind queued und processing möglich. progress liegt zwischen 0 und 1. Das Ergebnis enthält außerdem model, usage, flowai_request_id und expires_at. Bei angeforderten Zeitstempeln beziehen sich start und end auf die gesamte Aufnahme, auch wenn sie in Abschnitten verarbeitet wird.
POST /audio/transcriptions/{id}/cancel verhindert weitere Abschnitte; ein bereits bezahlter Anbieteraufruf darf noch abgeschlossen werden. Bei Fehler oder Abbruch können bestätigte Teilergebnisse vorliegen. DELETE /audio/transcriptions/{id} löscht nur abgeschlossene Aufträge. Große Groq-, OpenAI- und IONOS-Aufnahmen werden in begrenzte Abschnitte zerlegt und in Originalreihenfolge zusammengesetzt.
Live-Sitzung erstellen und verbinden
POST /audio/transcription-sessions erwartet model und source: push für Audio aus deiner App oder url mit einem direkten öffentlichen HTTP(S)-Audiostream in url. Optional sind language, timestamps, diarize und max_seconds. Die Standardlaufzeit beträgt zwei Stunden, die Höchstlaufzeit acht Stunden. Gleichzeitig sind höchstens drei aktive Sitzungen je Team möglich.
Die Antwort mit HTTP 201 liefert id, websocket_url, ticket und ticket_expires_at. Das Ticket gilt 60 Sekunden, ist an die Sitzung gebunden und wird beim Verbinden einmalig verbraucht. Übertrage es als WebSocket-Unterprotokoll flowai-ticket.TICKET. POST /audio/transcription-sessions/{id}/connection-ticket stellt ein neues Ticket aus und ersetzt das vorherige. FlowModels- und Anbieterschlüssel gehören nicht in die WebSocket-URL.
Apps senden binäre Frames mit PCM16 Little Endian, mono, 24 kHz. Das sind 48.000 Bytes pro Sekunde. Jeder Frame muss eine gerade Bytezahl und höchstens 48.000 Bytes enthalten; sende in Wiedergabegeschwindigkeit. Bei URL-Quellen dekodiert der Server das Audio; der Client empfängt nur Ereignisse. Private Netzwerkziele, Zugangsdaten in URLs, HLS-Playlists und Plattformseiten werden nicht unterstützt. MP4/M4A-Streams benötigen Metadaten vor den Audiodaten oder fragmentiertes MP4; Dateien mit nachgelagerten Metadaten gehören an den Datei-Endpunkt.
Mit {"type":"audio.commit"} schließt du einen OpenAI-Sprachabschnitt ab; der Server tut dies spätestens nach jeweils zehn Sekunden Audio. {"type":"session.stop"} oder POST /audio/transcription-sessions/{id}/stop beendet die Aufnahme und verarbeitet ausstehende Ergebnisse. Zustände sind waiting, running, stopping und anschließend completed oder failed.
Ereignisse und Wiederverbindung
session.ready: Die Client-Verbindung steht. Audio kann während des Anbieterstarts kurz gepuffert werden.
transcript.partial: Ersetze den bisherigen Entwurf derselben section_id durch text. Zwischenstände werden nicht dauerhaft gespeichert.
transcript.final: Bestätigter Text mit stabiler id, fortlaufender sequence und optionalen segments. Entferne den zugehörigen Entwurf und vermeide Duplikate anhand der ID.
connection.interrupted: Unterbrechung mit reason und audio_replayed:false.
usage: Bisherige Audiodauer und Abrechnungsstatus. Den genauen EUR-Betrag liefert der REST-Abruf.
session.completed: Abschluss mit status, gegebenenfalls error und Audiodauer.
Speichere die letzte bestätigte Sequenznummer. Nach einer Client-Wiederverbindung rufst du GET /audio/transcription-sessions/{id}?after_sequence=N ab. Jede Seite enthält höchstens 1.000 bestätigte Abschnitte; folge next_after_sequence bis last_sequence. text enthält den Text dieser Seite. WebSocket-Ereignisse und REST-Abruf können sich überschneiden, deshalb musst du nach ID deduplizieren.
Eine getrennte Push-Verbindung kannst du innerhalb von 30 Sekunden mit einem neuen Ticket wieder anbinden; danach wird die Aufnahme beendet. OpenAI-Verbindungen werden nach 50 Minuten kontrolliert erneuert. Abschnittsreihenfolge und Aufnahmeversatz bleiben erhalten. Unklar verarbeitetes Audio wird nicht automatisch erneut kostenpflichtig gesendet. Ungesendetes Audio wird höchstens im Umfang von fünf Sekunden gepuffert; bei Überschreitung endet die Sitzung kontrolliert.
Direkten Audiostream beobachten
Dieses Beispiel läuft mit Node.js ab Version 22. Setze FLOWMODELS_BASE_URL, FLOWMODELS_API_KEY und FLOWMODELS_AUDIO_URL in deinem Backend. Es beobachtet den Stream für 30 Sekunden und fordert dann den Abschluss an.
Dateiaufträge reservieren vor dem ersten Anbieteraufruf die geschätzten Gesamtkosten. Live-Sitzungen reservieren zunächst 60 Sekunden und erweitern die Reservierung, bevor weiteres Audio übertragen wird. Preise hängen von Modell, Datei-/Live-Betrieb und kostenpflichtigen Zusatzoptionen ab. Auch Stille kann kostenpflichtig sein; Groq rechnet mindestens zehn Sekunden je Anbieteraufruf ab, auch je Dateiabschnitt. Verfügbare tatsächliche Anbieter-Tokens werden berücksichtigt. usage.cost und usage.cost_micro_eur zeigen abgerechnete Kosten, keine noch offenen Reservierungen.
Verwende für die Erstellung einen Idempotency-Key und wiederhole bei unklarer Antwort dieselbe Anfrage mit demselben Schlüssel. Eine Ticket-Erneuerung erhält einen neuen Idempotenzschlüssel. Guthaben, Schlüsselsperren und Teamgrenzen gelten auch während der Verarbeitung. Unklare Anbieterfehler können eine offene Reservierung hinterlassen, bis der Verbrauch geklärt ist.
Fertige Ergebnisse bleiben 24 Stunden nach Abschluss abrufbar. expires_at beschreibt diese Aufbewahrungsfrist, ticket_expires_at ausschließlich die Ticketgültigkeit. Uploads und Arbeitsdateien werden nach Abschluss, Abbruch oder Fehler gelöscht. Abgeschlossene Live-Sitzungen löschst du mit DELETE /audio/transcription-sessions/{id}.
Typische Fehler: HTTP 422 bei ungeeigneten Optionen, Grenzen oder Quellen; HTTP 429 bei zu vielen parallelen Sitzungen; HTTP 503 mit audio_disabled, audio_model_unavailable oder audio_pricing_unavailable, wenn die Funktion, das Modell oder der Preis nicht verfügbar ist. Ein WebSocket-Upgrade mit ungültigem, abgelaufenem oder bereits verbrauchtem Ticket wird abgelehnt. Bei angenommenen Aufträgen und Sitzungen prüfst du zusätzlich status und error; ein erfolgreicher Statusabruf bedeutet noch keine erfolgreiche Transkription.
Verfügbarkeit von Live-Transkription
Live-Transkription wird getrennt freigeschaltet und steht nur für Modelle zur Verfügung, die GET /models mit dem Wert live in transcription.modes ausweist. Die Tabelle oben beschreibt, welche Betriebsart ein Modell grundsätzlich beherrscht; maßgeblich für deine Integration ist deine aktuelle Modellliste.
Videos werden im Hintergrund erzeugt. Du startest einen Auftrag, erhältst sofort 202 mit einer Auftrags-ID und fragst den Status ab oder lässt dich per Webhook benachrichtigen. Es gibt keinen automatischen Modellwechsel.
Modell
Eingabe
Dauer (Sekunden)
Auflösung
Seitenverhältnis
Weitere Felder
bytedance/seedance-2.5/text-to-video
Prompt
4 bis 30
480p, 720p, 1080p
16:9, 4:3, 1:1, 3:4, 9:16, 21:9
generate_audio, output_format
bytedance/seedance-2.5/image-to-video
Bild, optional Prompt und Endbild
4 bis 30
480p, 720p, 1080p
Folgt dem Bild
generate_audio
minimax/h3/text-to-video
Prompt
5 bis 15
2K
auto, adaptive, 21:9, 16:9, 4:3, 1:1, 3:4, 9:16
aigc_watermark
minimax/h3/image-to-video
Bild und Prompt, optional Endbild
5 bis 15
2K
Wie Text-zu-Video
aigc_watermark
alibaba/wan-3.0/text-to-video
Prompt
2 bis 30
480p, 720p, 1080p
16:9, 4:3, 1:1, 3:4, 9:16, adaptive
generate_audio, enable_thinking, seed
alibaba/wan-3.0/image-to-video
Bild und Prompt, optional Endbild
2 bis 30
480p, 720p, 1080p
Wie Text-zu-Video
generate_audio, enable_thinking, seed
Verwende nur Modelle aus deiner aktuellen Antwort von GET /models; ein noch nicht freigegebenes Modell wird abgelehnt. Felder, die ein Modell nicht kennt, und unbekannte Felder werden vor jeder Reservierung mit 422 und param abgelehnt. Beispielsweise akzeptiert Seedance Bild-zu-Video weder aspect_ratio noch output_format, und Modelle ohne Tonspur lehnen generate_audio ab.
Bilder übergeben
Bild-zu-Video-Modelle brauchen ein Startbild, entweder als image_url (öffentliche https-Adresse oder data:-URL) oder als image_file_id einer Datei dieses Teams aus POST /files. Erlaubt sind JPEG, PNG, WebP und GIF bis 10 MiB. Für das Endbild gelten dieselben Regeln mit end_image_url oder end_image_file_id. Eine fremde oder unbekannte Datei wird mit 422 video_input_invalid abgelehnt.
Ablauf und Status
POST /videos prüft die Parameter, reserviert den vollen Preis der gewünschten Sekunden und antwortet mit 202.
status ist zunächst queued, dann in_progress, schließlich completed, failed oder cancelled. Frage in Abständen von mindestens fünf Sekunden ab oder verwende Webhooks.
Ist das Video fertig, enthält die Antwort content_url, content_type und size_bytes. GET /videos/{id}/content antwortet mit 302 auf eine Download-URL, die 15 Minuten gilt.
Das Video bleibt sieben Tage ab Fertigstellung abrufbar, danach werden Datei und Auftrag automatisch gelöscht. expires_at nennt den genauen Zeitpunkt. DELETE /videos/{id} löscht einen beendeten Auftrag früher.
POST /videos/{id}/cancel bricht einen Auftrag ab, solange er noch nicht läuft, und gibt die Reservierung frei. Hat die Generierung bereits begonnen, antwortet die API mit 409 video_not_cancellable; der Auftrag läuft dann zu Ende und wird abgerechnet. Antwortet die API mit 202, wird der Abbruch noch ausgeführt; prüfe das Ergebnis über GET /videos/{id}.
Kosten und Reservierung
Abgerechnet wird pro Sekunde des fertigen Videos zum Preis der gewählten Kombination aus Modell, Auflösung, Ton und gegebenenfalls enable_thinking. pricing.variants in GET /models nennt je Variante den Preis in EUR je Sekunde. Der Preis wird beim Start des Auftrags festgeschrieben und bis zur Fertigstellung reserviert. Berechnet wird nur ein Video, das erfolgreich bei uns gespeichert wurde; fehlgeschlagene, abgelehnte und abgebrochene Aufträge kosten nichts. Fehlt für eine Kombination ein Preis, antwortet die API mit 503 video_pricing_unavailable und startet nichts.
Grenzen und Fehlercodes
Die Anzahl gleichzeitig aktiver Videos hängt von deiner Rate-Limit-Stufe ab: 3, 5, 10 oder 20 je Team. Wird die Grenze überschritten, antwortet die API mit 429 video_concurrency_exceeded und Retry-After. Mit dem Kopfzeilenwert Idempotency-Key kannst du eine Anfrage nach einem Netzwerkfehler gefahrlos wiederholen; es entsteht kein zweites Video.
422 invalid_video_request: Feld passt nicht zum Modell, siehe param.
422 video_input_invalid: Bild fehlt, ist ungültig oder zu groß.
429 insufficient_quota, 429 spend_limit_exceeded: Guthaben oder Ausgabenlimit reicht nicht aus.
429 video_concurrency_exceeded: Zu viele aktive Videos.
503 video_model_unavailable, 503 video_pricing_unavailable, 503 video_provider_unavailable: Später erneut versuchen, das Guthaben wurde nicht belastet.
503 video_storage_unavailable: Das Video konnte gerade nicht gelöscht werden, der Auftrag bleibt erhalten. Später erneut versuchen, siehe Retry-After.
404 video_not_found: Unbekannte oder fremde Auftrags-ID.
409 video_not_cancellable, 409 video_not_deletable, 409 video_not_ready: Der aktuelle Status lässt die Aktion nicht zu.
Ein Auftrag mit statusfailed enthält error.code, zum Beispiel video_generation_failed oder video_content_rejected. Webhooks liefern die Ereignisse video.completed, video.failed und video.cancelled; die Zustellung enthält nie den Prompt.
POST
/v1/videos
Video erstellen
Video erstellen. FlowModels-Schlüssel erforderlich.
Request Body
modelstring
erforderlich
Freigegebene Kennung aus GET /models, zum Beispiel bytedance/seedance-2.5/text-to-video
promptstring
Bei allen Text-zu-Video-Modellen sowie bei MiniMax und Wan für Bild-zu-Video erforderlich, bei Seedance Bild-zu-Video optional. Höchstens 7.000 Zeichen.
image_urlstring
Bei Bild-zu-Video erforderlich, sofern image_file_id nicht gesetzt ist: https-URL oder data:image/...;base64-URL. JPEG, PNG, WebP oder GIF, höchstens 10 MiB.
image_file_idstring
file_id einer zuvor hochgeladenen Bilddatei dieses Teams, statt image_url
end_image_urlstring
Endbild, nur bei Bild-zu-Video-Modellen. Gleiche Formate wie image_url.
end_image_file_idstring
file_id des Endbilds, statt end_image_url
durationinteger
Dauer in Sekunden, Bereich je Modell, siehe Tabelle. Standard 5.
resolutionstring
Auflösung je Modell, siehe Tabelle
aspect_ratiostring
Seitenverhältnis je Modell. Seedance Bild-zu-Video lehnt dieses Feld ab.
generate_audioboolean
Ton erzeugen. Nur Seedance und Wan, Standard true.
output_formatstring
mp4 oder mov. Nur Seedance Text-zu-Video.
enable_thinkingboolean
Nur Wan, Standard false. Eigener Preis je Sekunde.
seedinteger
Nur Wan, 0 bis 2147483647
aigc_watermarkboolean
Nur MiniMax, Standard false
curl --fail-with-body "https://api.flowmodels.one/v1/videos" \
-H "Authorization: Bearer $FLOWMODELS_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: $(uuidgen)" \
-d '{"model":"bytedance/seedance-2.5/text-to-video","prompt":"Ein Papierboot auf einem ruhigen See bei Sonnenaufgang","duration":5,"resolution":"720p"}'
# Status abfragen, bis status "completed", "failed" oder "cancelled" ist
curl --fail-with-body "https://api.flowmodels.one/v1/videos/$VIDEO_ID" \
-H "Authorization: Bearer $FLOWMODELS_API_KEY"
# Fertiges Video herunterladen (302 auf eine kurzlebige Download-URL)
curl -L --fail-with-body "https://api.flowmodels.one/v1/videos/$VIDEO_ID/content" \
-H "Authorization: Bearer $FLOWMODELS_API_KEY" -o video.mp4
import os
import time
import uuid
import requests
headers = {'Authorization': f"Bearer {os.environ['FLOWMODELS_API_KEY']}"}
job = requests.post(
'https://api.flowmodels.one/v1/videos',
headers={**headers, 'Idempotency-Key': str(uuid.uuid4())},
json={
'model': 'bytedance/seedance-2.5/text-to-video',
'prompt': 'Ein Papierboot auf einem ruhigen See bei Sonnenaufgang',
'duration': 5,
'resolution': '720p',
},
timeout=30,
).json()
while job['status'] in ('queued', 'in_progress'):
time.sleep(10)
job = requests.get(f"https://api.flowmodels.one/v1/videos/{job['id']}", headers=headers, timeout=30).json()
print(job['status'], job['content_url'])
// Keep the API key in your backend.
const headers = {
Authorization: `Bearer ${process.env.FLOWMODELS_API_KEY}`,
'Content-Type': 'application/json',
};
const created = await fetch('https://api.flowmodels.one/v1/videos', {
method: 'POST',
headers: { ...headers, 'Idempotency-Key': crypto.randomUUID() },
body: JSON.stringify({
model: 'bytedance/seedance-2.5/text-to-video',
prompt: 'Ein Papierboot auf einem ruhigen See bei Sonnenaufgang',
duration: 5,
resolution: '720p',
}),
});
if (!created.ok) throw new Error(`HTTP ${created.status}`);
let job = await created.json();
while (job.status === 'queued' || job.status === 'in_progress') {
await new Promise((resolve) => setTimeout(resolve, 10000));
job = await (await fetch(`https://api.flowmodels.one/v1/videos/${job.id}`, { headers })).json();
}
console.log(job.status, job.content_url);
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Str;
$client = Http::withToken(getenv('FLOWMODELS_API_KEY'))->acceptJson();
$job = $client->withHeaders(['Idempotency-Key' => (string) Str::uuid()])
->post('https://api.flowmodels.one/v1/videos', [
'model' => 'bytedance/seedance-2.5/text-to-video',
'prompt' => 'Ein Papierboot auf einem ruhigen See bei Sonnenaufgang',
'duration' => 5,
'resolution' => '720p',
])->throw()->json();
do {
sleep(10);
$job = $client->get('https://api.flowmodels.one/v1/videos/'.$job['id'])->throw()->json();
} while (in_array($job['status'], ['queued', 'in_progress'], true));
Ein Bild entsteht innerhalb der Anfrage: Du sendest einen Prompt und erhältst das fertige Bild in derselben Antwort, meist nach wenigen Sekunden. Es gibt keinen automatischen Modellwechsel.
Modell
Größen
Qualität
Bearbeiten
openai/gpt-image-2.6-sunburst
square, portrait, landscape, 2k
low, medium
Ja
google/gemini-3.1-flash-image
square, portrait, landscape, 2k
medium
Nein
google/gemini-nano-banana-2.1
square, portrait, landscape, 2k
medium
Nein
minimax/h3-image
square, portrait, landscape, 2k
medium
Ja
minimax/h3-image-highspeed
square, portrait, landscape, 2k
medium
Ja
ionos/black-forest-labs/FLUX.2-klein-4B
square, portrait, landscape, 2k
medium
Ja
ionos/black-forest-labs/FLUX.2-klein-4B läuft im IONOS AI Model Hub in Berlin (DSGVO, EU-gehostet). Das Modell berücksichtigt laut IONOS nur die ersten 256 Token des Prompts; ein längerer Prompt wird angenommen, sein Rest aber nicht umgesetzt.
Die frühere ID google/gemini-3.1-flash-image-preview wird weiter angenommen. Google hat dieses Vorschaumodell abgeschaltet, deshalb wird die Anfrage mit google/gemini-3.1-flash-image erzeugt und zu dessen Preis abgerechnet; model in der Antwort nennt dieses Modell.
square ist quadratisch, portrait hochkant, landscape quer und 2k ein breites Querformat in höherer Auflösung. Verwende nur Modelle aus deiner aktuellen Antwort von GET /models; dort stehen unter image die Größen, Qualitäten und ob das Modell bearbeiten kann. Felder, die ein Modell nicht kennt, und unbekannte Felder werden vor jeder Reservierung mit 422 und param abgelehnt.
Bilder bearbeiten
POST /images/edits nimmt zusätzlich ein Bild entgegen, entweder als image_url (öffentliche https-Adresse oder data:-URL) oder als image_file_id einer Datei dieses Teams aus POST /files. Erlaubt sind JPEG, PNG und WebP bis 10 MiB. Eine fremde oder unbekannte Datei wird mit 422 image_input_invalid abgelehnt. Für ionos/black-forest-labs/FLUX.2-klein-4B muss das Bild auf jeder Seite mindestens 64 Pixel groß sein und darf kein extremeres Seitenverhältnis als 8:1 haben, sonst ebenfalls 422 image_input_invalid. Das Ergebnis hat immer die gewählte Größe.
Antwort und Abruf
Die Antwort folgt dem Aufbau der OpenAI-Bilder-API: created und data mit genau einem Eintrag. Mit response_formaturl enthält er eine Download-Adresse, mit b64_json das Bild selbst als Base64. Dazu kommen id, content_type, size_bytes, expires_at und usage. GET /images/{id}/content antwortet mit 302 auf eine Download-URL, die 15 Minuten gilt. Das Bild bleibt sieben Tage abrufbar, danach wird es automatisch gelöscht. DELETE /images/{id} löscht es früher.
Kosten und Reservierung
Abgerechnet wird je Bild zum Preis der gewählten Kombination aus Modell, Größe und Qualität. pricing.variants in GET /models nennt je Variante den Preis in EUR je Bild. Der Betrag wird vor der Erzeugung reserviert und erst abgebucht, wenn das Bild bei uns gespeichert ist. Abgelehnte und fehlgeschlagene Anfragen kosten nichts. Fehlt für ein Modell ein Preis, antwortet die API mit 503 image_pricing_unavailable und erzeugt nichts.
Grenzen und Fehlercodes
Eine Erzeugung belegt einen Platz der gleichzeitigen Anfragen deiner Rate-Limit-Stufe. Mit dem Kopfzeilenwert Idempotency-Key kannst du eine Anfrage nach einem Netzwerkfehler gefahrlos wiederholen; es entsteht kein zweites Bild. Webhooks gibt es für Bilder nicht, weil die Antwort das fertige Bild enthält.
422 invalid_image_request: Feld passt nicht zum Modell, siehe param.
422 image_input_invalid: Das zu bearbeitende Bild fehlt, ist ungültig oder zu groß.
422 image_request_rejected: Das Modell hat die Anfrage abgelehnt.
422 image_content_rejected: Das Bild wurde aufgrund seines Inhalts abgelehnt.
429 insufficient_quota, 429 spend_limit_exceeded: Guthaben oder Ausgabenlimit reicht nicht aus.
503 image_model_unavailable, 503 image_pricing_unavailable, 503 image_provider_unavailable: Später erneut versuchen, das Guthaben wurde nicht belastet.
404 image_not_found: Unbekannte, abgelaufene oder fremde Bild-ID.
409 image_not_ready, 409 image_not_deletable: Der aktuelle Status lässt die Aktion nicht zu.
POST
/v1/images/generations
Bild erzeugen
Bild erzeugen. FlowModels-Schlüssel erforderlich.
Request Body
modelstring
erforderlich
Freigegebene Kennung aus GET /models, zum Beispiel openai/gpt-image-2.6-sunburst
promptstring
erforderlich
Beschreibung des Bildes, höchstens 4.000 Zeichen
sizestring
square, portrait, landscape oder 2k. Standard square.
qualitystring
low oder medium bei openai/gpt-image-2.6-sunburst (Standard low), nur medium bei google/gemini-3.1-flash-image, google/gemini-nano-banana-2.1, minimax/h3-image, minimax/h3-image-highspeed und ionos/black-forest-labs/FLUX.2-klein-4B
ninteger
Anzahl der Bilder, nur 1 erlaubt
response_formatstring
url (Standard) oder b64_json
curl -X POST "https://api.flowmodels.one/v1/images/generations" \
-H "Authorization: Bearer $FLOWMODELS_API_KEY" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-d '{"model": "openai/gpt-image-2.6-sunburst", "prompt": "Ein Papierboot auf einem ruhigen See bei Sonnenaufgang", "size": "landscape", "quality": "low"}'
import os
import requests
headers = {
'Authorization': f'Bearer {os.environ["FLOWMODELS_API_KEY"]}',
'Accept': 'application/json',
}
payload = {
'model': "openai/gpt-image-2.6-sunburst",
'prompt': "Ein Papierboot auf einem ruhigen See bei Sonnenaufgang",
'size': "landscape",
'quality': "low",
}
response = requests.post(
'https://api.flowmodels.one/v1/images/generations',
headers=headers,
json=payload,
)
data = response.json()
const response = await fetch('https://api.flowmodels.one/v1/images/generations', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.FLOWMODELS_API_KEY}`,
'Accept': 'application/json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: "openai/gpt-image-2.6-sunburst",
prompt: "Ein Papierboot auf einem ruhigen See bei Sonnenaufgang",
size: "landscape",
quality: "low",
}),
});
const data = await response.json();
use Illuminate\Support\Facades\Http;
$response = Http::withToken(getenv('FLOWMODELS_API_KEY'))
->post('https://api.flowmodels.one/v1/images/generations', [
'model' => 'openai/gpt-image-2.6-sunburst',
'prompt' => 'Ein Papierboot auf einem ruhigen See bei Sonnenaufgang',
'size' => 'landscape',
'quality' => 'low',
]);
$data = $response->json();
Freigegebene Kennung aus GET /models, zum Beispiel openai/gpt-image-2.6-sunburst
promptstring
erforderlich
Beschreibung des Bildes, höchstens 4.000 Zeichen
sizestring
square, portrait, landscape oder 2k. Standard square.
qualitystring
low oder medium bei openai/gpt-image-2.6-sunburst (Standard low), nur medium bei google/gemini-3.1-flash-image, google/gemini-nano-banana-2.1, minimax/h3-image, minimax/h3-image-highspeed und ionos/black-forest-labs/FLUX.2-klein-4B
ninteger
Anzahl der Bilder, nur 1 erlaubt
response_formatstring
url (Standard) oder b64_json
image_urlstring
Zu bearbeitendes Bild, sofern image_file_id nicht gesetzt ist: https-URL oder data:image/...;base64-URL. JPEG, PNG oder WebP, höchstens 10 MiB.
image_file_idstring
file_id einer zuvor hochgeladenen Bilddatei dieses Teams, statt image_url
curl -X POST "https://api.flowmodels.one/v1/images/edits" \
-H "Authorization: Bearer $FLOWMODELS_API_KEY" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-d '{"model": "openai/gpt-image-2.6-sunburst", "prompt": "Mach daraus eine Nachtszene mit Laternen", "image_url": "https://example.com/boot.png"}'
import os
import requests
headers = {
'Authorization': f'Bearer {os.environ["FLOWMODELS_API_KEY"]}',
'Accept': 'application/json',
}
payload = {
'model': "openai/gpt-image-2.6-sunburst",
'prompt': "Mach daraus eine Nachtszene mit Laternen",
'image_url': "https://example.com/boot.png",
}
response = requests.post(
'https://api.flowmodels.one/v1/images/edits',
headers=headers,
json=payload,
)
data = response.json()
POST /decisions beantwortet benannte Fragen zu einem gemeinsamen Inhalt mit Wahrscheinlichkeiten statt mit Fließtext. Das Format folgt der Decisions API von OpenAI, du kannst eine bestehende Integration also übernehmen. Es gibt vier Fragetypen:
predicate: Ja oder nein. Antwort probability von 0 bis 1.
choice: eine von mehreren Möglichkeiten aus choices. Antwort choice, probabilities je Möglichkeit und confidence.
score: eine Bewertung auf den Stufen in levels, von niedrig nach hoch. Antwort score (wahrscheinlichkeitsgewichteter Mittelwert der Stufen ab 0), probabilities je Stufe und confidence.
box: nur bei TypeSafe Jev. Ortet das Beschriebene in einem Bild aus input. Antwort box mit top, bottom, left und right als Anteil von Bildhöhe und Bildbreite (0 bis 1) und confidence (kann null sein).
Die Antworten stehen in answers in der Reihenfolge deiner Fragen und nennen jeweils den name der Frage. Lehnt ein Modell eine einzelne Frage ab, steht dort type: refusal.
Modelle und Fähigkeiten
Modell
Fragetypen
Fragen je Anfrage
Bilder
Textgrenze
openai/decisions/gpt-6-luna
predicate, choice, score
400
Ja
Vom Anbieter geprüft
typesafe/jev-1.14.0
predicate, choice, score, box
100
Ja, PNG und JPEG
256.000 Zeichen Eingabe, 128.000 je Frage
typesafe/jev-latest
wie jev-1.14.0
100
Ja, PNG und JPEG
wie jev-1.14.0
typesafe/jev-latest zeigt immer auf das aktuelle Jev-Modell. openai/decisions/gpt-6-luna ist das Modell gpt-6-luna über die Decisions API von OpenAI; das gleichnamige Chatmodell openai/gpt-6-luna bleibt davon unberührt und ist hier nicht verwendbar. GET /models führt die drei Entscheidungsmodelle als kind: decision und nennt unter decision ihre Fähigkeiten. Bis zu acht Bilder je Anfrage sind erlaubt, in input und in den instructions einer Frage zusammen. prompt_cache_key gibt es nur bei OpenAI.
Prüfung vor jeder Reservierung
Ein falsch aufgebauter Body wird mit 400 invalid_field_value abgelehnt, ein Feld, das das gewählte Modell nicht kann (etwa box bei OpenAI oder zu viele Fragen), mit 422 unsupported_for_model. In beiden Fällen nennt param den vollständigen Feldpfad, zum Beispiel questions.3.type. Unbekannte Felder werden abgelehnt, nicht ignoriert.
Kosten
Abgerechnet werden nur Input-Tokens, Output ist kostenlos. Bei OpenAI enthält usage.input_tokens bereits die gelesenen und geschriebenen Cache-Tokens aus input_tokens_details; gelesene Cache-Tokens kosten weniger. pricing in GET /models nennt die Preise in EUR je 1 Mio. Tokens (input, cached_input, cache_write). Vor dem Aufruf wird eine Obergrenze reserviert, abgebucht wird der tatsächliche Verbrauch. Liefert das Modell keine verwertbare Antwort, kostet die Anfrage nichts.
usage.cost (EUR als Dezimalzahl) und usage.cost_micro_eur nennen den abgebuchten Betrag, usage.cost_status seinen Stand: settled, wenn der Betrag gebucht ist, pending, wenn die Buchung nachgeholt wird. Solange pending gilt, sind cost und cost_micro_eurnull; danach ist der endgültige Betrag in GET /usage enthalten.
Fehlercodes
400 invalid_field_value: Der Body ist nicht wohlgeformt, siehe param.
404 model_not_found: Die Kennung ist kein Entscheidungsmodell.
413 payload_too_large, 415 invalid_content_type: Body zu groß oder kein JSON.
422 unsupported_for_model: Feld passt nicht zum Modell, siehe param.
422 decision_input_invalid: Ein Bild ist ungültig, nicht abrufbar oder im falschen Format.
422 decision_request_rejected: Das Modell hat die Anfrage abgelehnt, es wurde nichts berechnet.
429 insufficient_quota, 429 spend_limit_exceeded: Guthaben oder Ausgabenlimit reicht nicht aus.
429 decision_provider_rate_limited: Der Anbieter ist ausgelastet, warte die Sekunden aus Retry-After.
502 decision_provider_invalid_response, 503 decision_provider_unavailable, 503 decision_model_unavailable, 503 decision_pricing_unavailable: Später erneut versuchen, das Guthaben wurde nicht belastet.
POST
/v1/decisions
Entscheidungen abfragen
Typisierte Fragen zu einem gemeinsamen Inhalt beantworten. FlowModels-Schlüssel erforderlich.
Request Body
modelstring
erforderlich
openai/decisions/gpt-6-luna, typesafe/jev-1.14.0 oder typesafe/jev-latest (siehe GET /models, kind decision)
inputstring|array
erforderlich
Gemeinsamer Inhalt für alle Fragen: eine Zeichenfolge oder eine Liste von Nachrichten mit role (user, developer, system) und content. In user-Nachrichten sind die Teile input_text, input_image (image_url als https- oder Data-URL) und input_json (data) erlaubt, in developer- und system-Nachrichten nur input_text.
questionsarray
erforderlich
1 bis 400 Fragen (je nach Modell weniger), jede mit type (predicate, choice, score, box), eindeutigem name und instructions (Zeichenfolge oder Liste aus input_text und input_image). choice braucht choices [{value, description}] mit 2 bis 255 eindeutigen Einträgen, score braucht levels [{label, description}] mit 2 bis 10 Stufen von niedrig nach hoch. description ist jeweils optional, empfohlen ist eine kurze Beschreibung.
prompt_cache_keystring
Nur openai/decisions/gpt-6-luna: Schlüssel, der die Wiederverwendung des Prompt-Caches aufteilt
curl -X POST "https://api.flowmodels.one/v1/decisions" \
-H "Authorization: Bearer $FLOWMODELS_API_KEY" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-d '{"model": "typesafe/jev-latest", "input": "Mir wurde das Abo diesen Monat doppelt berechnet. Bitte erstattet den zweiten Betrag.", "questions": [{"type":"predicate","name":"doppelte_abbuchung","instructions":"Beschreibt die Nachricht eine doppelte Abbuchung?"},{"type":"choice","name":"abteilung","instructions":"Welche Abteilung ist zuständig?","choices":[{"value":"buchhaltung","description":"Zahlungen und Erstattungen"},{"value":"technik","description":"Fehler und Störungen"}]},{"type":"score","name":"dringlichkeit","instructions":"Wie dringend ist die Nachricht?","levels":[{"label":"Kann warten","description":"Keine Frist"},{"label":"Diese Woche","description":"Sollte bald bearbeitet werden"},{"label":"Heute","description":"Sofort bearbeiten"}]}]}'
import os
import requests
headers = {
'Authorization': f'Bearer {os.environ["FLOWMODELS_API_KEY"]}',
'Accept': 'application/json',
}
payload = {
'model': "typesafe/jev-latest",
'input': "Mir wurde das Abo diesen Monat doppelt berechnet. Bitte erstattet den zweiten Betrag.",
'questions': [{"type": "predicate", "name": "doppelte_abbuchung", "instructions": "Beschreibt die Nachricht eine doppelte Abbuchung?"}, {"type": "choice", "name": "abteilung", "instructions": "Welche Abteilung ist zuständig?", "choices": [{"value": "buchhaltung", "description": "Zahlungen und Erstattungen"}, {"value": "technik", "description": "Fehler und Störungen"}]}, {"type": "score", "name": "dringlichkeit", "instructions": "Wie dringend ist die Nachricht?", "levels": [{"label": "Kann warten", "description": "Keine Frist"}, {"label": "Diese Woche", "description": "Sollte bald bearbeitet werden"}, {"label": "Heute", "description": "Sofort bearbeiten"}]}],
}
response = requests.post(
'https://api.flowmodels.one/v1/decisions',
headers=headers,
json=payload,
)
data = response.json()
const response = await fetch('https://api.flowmodels.one/v1/decisions', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.FLOWMODELS_API_KEY}`,
'Accept': 'application/json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: "typesafe/jev-latest",
input: "Mir wurde das Abo diesen Monat doppelt berechnet. Bitte erstattet den zweiten Betrag.",
questions: [{"type":"predicate","name":"doppelte_abbuchung","instructions":"Beschreibt die Nachricht eine doppelte Abbuchung?"},{"type":"choice","name":"abteilung","instructions":"Welche Abteilung ist zuständig?","choices":[{"value":"buchhaltung","description":"Zahlungen und Erstattungen"},{"value":"technik","description":"Fehler und Störungen"}]},{"type":"score","name":"dringlichkeit","instructions":"Wie dringend ist die Nachricht?","levels":[{"label":"Kann warten","description":"Keine Frist"},{"label":"Diese Woche","description":"Sollte bald bearbeitet werden"},{"label":"Heute","description":"Sofort bearbeiten"}]}],
}),
});
const data = await response.json();
Ohne external_identifier bleibt die Kontextverwaltung beim Client. Mit Kennung ergänzt Brain den gespeicherten Verlauf, Erinnerungen und relevante Dateiabschnitte. Beide Varianten unterstützen Streaming.
Eine Unterhaltung beginnen
Das folgende Beispiel führt einen Aufruf ohne gespeicherten Endnutzerkontext aus. Ersetze den Token und wähle ein Modell aus deiner aktuellen Modellliste. Sende für Brain zusätzlich external_identifier als JSON-Zeichenfolge mit. Die vollständige Modellkennung und der FlowModels-Schlüssel bleiben in beiden Varianten gleich.
Eigene Funktionen aufrufen lassen
Du kannst dem Modell eigene Funktionen anbieten. FlowModels führt diese Funktionen nicht aus. Das Modell entscheidet, welche Funktion mit welchen Argumenten aufgerufen werden soll, du führst den Aufruf in deinem eigenen System aus und sendest das Ergebnis im nächsten Zug zurück. Der Ablauf besteht deshalb immer aus zwei abgerechneten Anfragen.
Erster Zug. Du sendest tools und optional tool_choice:
{
"model": "groq/openai/gpt-oss-120b",
"messages": [{"role": "user", "content": "Wie ist das Wetter in Berlin?"}],
"tools": [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Aktuelles Wetter einer Stadt.",
"parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}
}
}]
}
Die Antwort trägt finish_reason: "tool_calls", content: null und die gewünschten Aufrufe. arguments ist eine Zeichenkette mit JSON, kein Objekt:
Zweiter Zug ohne Brain. Du sendest den bisherigen Verlauf, die Nachricht des Modells und dein Ergebnis als Nachricht mit role: "tool". Die tool_call_id muss der id aus dem Aufruf entsprechen, sonst antwortet die API mit HTTP 400:
{
"model": "groq/openai/gpt-oss-120b",
"messages": [
{"role": "user", "content": "Wie ist das Wetter in Berlin?"},
{"role": "assistant", "tool_calls": [{"id": "call_abc", "type": "function", "function": {"name": "get_weather", "arguments": "{"city":"Berlin"}"}}]},
{"role": "tool", "tool_call_id": "call_abc", "content": "12 Grad, bewölkt"}
],
"tools": [{"type": "function", "function": {"name": "get_weather", "parameters": {"type": "object", "properties": {"city": {"type": "string"}}}}}]
}
Beim Streaming kommen die Aufrufe in einem eigenen Chunk unmittelbar vor dem Abschlusschunk: choices[0].delta.tool_calls enthält den vollständigen Eintrag samt index, der Abschlusschunk trägt finish_reason: "tool_calls". Auf dem Endpunkt Responses erscheinen die Aufrufe stattdessen als Einträge vom Typ function_call in output, und du antwortest im nächsten Zug mit einem Eintrag vom Typ function_call_output.
Zweiter Zug mit Brain. Sende dieselbe external_identifier, die zurückgegebene conversation-UUID und nur das Tool-Ergebnis. Der gespeicherte Assistant-Aufruf bleibt serverseitig und die tool_call_id wird gegen diesen gespeicherten Call geprüft. Den gesamten alten Verlauf noch einmal mitzusenden erzeugt doppelten Kontext.
flowai_tools steuert etwas anderes, nämlich die serverseitigen Werkzeuge von FlowModels. Beide Felder zusammen in einer Anfrage werden mit HTTP 400 und invalid_field_value abgelehnt.
Strukturierte Ausgabe: was die Anbieter annehmen
json_object und json_schema in capabilities sagen dir, was ein Modell nativ beherrscht; fehlt die Fähigkeit, antwortet die API mit 400 unsupported_for_model. Anthropic-Modelle melden keine von beiden, Perplexity-Modelle nur json_schema. Bei Gemini-Modellen werden Schlüssel außerhalb des unterstützten Schema-Teilumfangs herausgefiltert. Lehnt ein Anbieter ein angefordertes Schema trotzdem ab, zum Beispiel strict: true mit einem ungültigen Schema, antwortet die API mit 400 invalid_field_value und param: response_format; der Fehlertext des Anbieters wird nicht weitergegeben.
POST
/v1/chat/completions
Chat-Completions
Sendet Nachrichten an ein freigegebenes Anbietermodell. Ohne Endnutzerkennung verwaltet der Client den Verlauf; mit Kennung ergänzt Brain den persönlichen Kontext.
Request Body
modelstring
erforderlich
Vollständige Kennung aus GET /models im Format provider/model-id
external_identifierstring
Aktiviert Brain-Kontext für deine stabile Endnutzerkennung mit 1 bis 255 Zeichen; im JSON-Body
messagesarray
erforderlich
Neue Nachrichten mit role und content; mindestens eine nicht leere Nutzernachricht
conversationuuid
UUID aus der vorherigen Antwort desselben Endnutzers; für eine neue Unterhaltung weglassen
max_tokensinteger
Obergrenze der Ausgabe, 1 bis 128.000. Ohne Angabe gilt das Maximum des Modells; ist für das Modell keines hinterlegt, greifen 4.096 Tokens. null zählt wie ohne Angabe. OpenAI-Modelle nehmen mindestens 16 Tokens an, ein kleinerer Wert wird mit 400 abgelehnt
streamboolean
true liefert Chat-Completions-Chunks als SSE; Standard false
context_compressionboolean
Erlaubt, einen zu langen selbst gesendeten Verlauf serverseitig zusammenzufassen; Standard false. Ohne diese Angabe wird ein zu langer Verlauf mit 400 context_length_exceeded abgelehnt statt gekürzt. Die Zusammenfassung ist ein zusätzlicher kostenpflichtiger Modellaufruf und wird in usage.flowai.compression ausgewiesen
reasoning_effortstring
Denktiefe des Modells: none, minimal, low, medium, high, xhigh oder max. Ohne Angabe gilt der Standard des Anbieters, es entsteht also kein Denkbudget, das du nicht angefordert hast. Welche Stufen ein Modell annimmt, steht in capabilities.reasoning_levels aus GET /models; eine nicht unterstützte Stufe wird mit HTTP 400 und unsupported_for_model abgelehnt
web_searchboolean
Schaltet die native Websuche des Anbieters ein. Standard ist aus, weil jede Suche zusätzlich abgerechnet wird. Modelle ohne native Suche lehnen true ab, Modelle mit fest eingebauter Suche (Perplexity, Groq Compound) lehnen false ab, jeweils mit HTTP 400 und unsupported_for_model; maßgeblich sind web_search und web_search_forced aus GET /models
response_formatobject
Ausgabeform: {"type":"text"}, {"type":"json_object"} oder {"type":"json_schema","json_schema":{"name":…,"schema":…,"strict":…}}. Die Felder json_object und json_schema aus GET /models sagen, was das Modell nativ beherrscht; fehlt die Fähigkeit, antwortet die API mit HTTP 400 und unsupported_for_model, statt still Fließtext zu liefern. Bei json_object ergänzt FlowModels einen kurzen JSON-Hinweis, wenn das Wort json in keiner Nachricht vorkommt, weil manche Anbieter den JSON-Modus sonst ablehnen. Bei json_schema gilt ohne Angabe strict: false. Lehnt der Anbieter das Schema trotzdem ab, antwortet die API mit HTTP 400, invalid_field_value und param response_format
toolsarray
Deine eigenen Funktionen im Format [{"type":"function","function":{"name":…,"description":…,"parameters":<JSON-Schema>}}]. Höchstens 128 Einträge, jede Beschreibung höchstens 65.536 Zeichen, jedes Schema höchstens 65.536 Bytes als JSON. FlowModels führt diese Funktionen nicht aus: Das Modell antwortet mit tool_calls, du führst die Funktion in deinem eigenen System aus und sendest das Ergebnis als Nachricht mit role "tool" zurück. Ob ein Modell Funktionen annimmt, steht in tools aus GET /models; fehlt die Fähigkeit, antwortet die API mit HTTP 400 und unsupported_for_model. Zusammen mit flowai_tools ist das Feld nicht erlaubt und wird mit HTTP 400 und invalid_field_value abgelehnt
tool_choicestring|object
Steuert die Werkzeugwahl: "auto", "none", "required" oder {"type":"function","function":{"name":…}} für genau eine Funktion. Nur zusammen mit tools erlaubt, und der genannte Name muss in tools vorkommen. Ohne Angabe gilt der Standard des Anbieters
parallel_tool_callsboolean
Erlaubt oder verbietet mehrere Funktionsaufrufe in einer Antwort. Nur zusammen mit tools erlaubt. Nicht jedes Modell kennt diesen Schalter; maßgeblich ist parallel_tool_calls aus GET /models, sonst antwortet die API mit HTTP 400 und unsupported_for_model
max_completion_tokensinteger
Dieselbe Angabe wie max_tokens, unter dem Namen der Responses-API. Beide zugleich mit unterschiedlichen Werten werden abgelehnt
stream_optionsobject
Nimmt ausschliesslich include_usage an und setzt stream: true voraus. Mit include_usage: true folgt ein abschliessender Chunk, der den Verbrauch der gestreamten Antwort nennt
userstring
Eigene Kennung des aufrufenden Endnutzers zur Missbrauchsnachverfolgung, bis 128 Zeichen. Diese Kennung ersetzt external_identifier nicht und aktiviert keinen Brain-Kontext
search_domain_filterarray
Beschränkt die native Websuche auf bis zu 20 Domains, etwa ["firma.de"], oder schließt sie mit vorangestelltem Minus aus, etwa ["-reddit.com"]. Entweder nur Freigaben oder nur Ausschlüsse; Domains ohne https:// und ohne Pfad, Subdomains sind eingeschlossen. Das Feld schaltet die Websuche ein und wird zusätzlich abgerechnet. Wie viele Domains das Modell annimmt, steht in GET /models unter capabilities.web_search_domain_filter_max (xAI 5, sonst 20); Modelle ohne Domainfilter wie Gemini lehnen das Feld mit 400 unsupported_for_model ab
Sendet Nachrichten an ein freigegebenes Anbietermodell. Ohne Endnutzerkennung verwaltet der Client den Verlauf; mit Kennung ergänzt Brain den persönlichen Kontext.
Request Body
modelstring
erforderlich
Vollständige Kennung aus GET /models im Format provider/model-id
external_identifierstring
Aktiviert Brain-Kontext für deine stabile Endnutzerkennung mit 1 bis 255 Zeichen; im JSON-Body
messagesarray
erforderlich
Neue Nachrichten mit role und content; mindestens eine nicht leere Nutzernachricht
conversationuuid
UUID aus der vorherigen Antwort desselben Endnutzers; für eine neue Unterhaltung weglassen
max_tokensinteger
Obergrenze der Ausgabe, 1 bis 128.000. Ohne Angabe gilt das Maximum des Modells; ist für das Modell keines hinterlegt, greifen 4.096 Tokens. null zählt wie ohne Angabe. OpenAI-Modelle nehmen mindestens 16 Tokens an, ein kleinerer Wert wird mit 400 abgelehnt
streamboolean
true liefert Chat-Completions-Chunks als SSE; Standard false
context_compressionboolean
Erlaubt, einen zu langen selbst gesendeten Verlauf serverseitig zusammenzufassen; Standard false. Ohne diese Angabe wird ein zu langer Verlauf mit 400 context_length_exceeded abgelehnt statt gekürzt. Die Zusammenfassung ist ein zusätzlicher kostenpflichtiger Modellaufruf und wird in usage.flowai.compression ausgewiesen
reasoning_effortstring
Denktiefe des Modells: none, minimal, low, medium, high, xhigh oder max. Ohne Angabe gilt der Standard des Anbieters, es entsteht also kein Denkbudget, das du nicht angefordert hast. Welche Stufen ein Modell annimmt, steht in capabilities.reasoning_levels aus GET /models; eine nicht unterstützte Stufe wird mit HTTP 400 und unsupported_for_model abgelehnt
web_searchboolean
Schaltet die native Websuche des Anbieters ein. Standard ist aus, weil jede Suche zusätzlich abgerechnet wird. Modelle ohne native Suche lehnen true ab, Modelle mit fest eingebauter Suche (Perplexity, Groq Compound) lehnen false ab, jeweils mit HTTP 400 und unsupported_for_model; maßgeblich sind web_search und web_search_forced aus GET /models
response_formatobject
Ausgabeform: {"type":"text"}, {"type":"json_object"} oder {"type":"json_schema","json_schema":{"name":…,"schema":…,"strict":…}}. Die Felder json_object und json_schema aus GET /models sagen, was das Modell nativ beherrscht; fehlt die Fähigkeit, antwortet die API mit HTTP 400 und unsupported_for_model, statt still Fließtext zu liefern. Bei json_object ergänzt FlowModels einen kurzen JSON-Hinweis, wenn das Wort json in keiner Nachricht vorkommt, weil manche Anbieter den JSON-Modus sonst ablehnen. Bei json_schema gilt ohne Angabe strict: false. Lehnt der Anbieter das Schema trotzdem ab, antwortet die API mit HTTP 400, invalid_field_value und param response_format
toolsarray
Deine eigenen Funktionen im Format [{"type":"function","function":{"name":…,"description":…,"parameters":<JSON-Schema>}}]. Höchstens 128 Einträge, jede Beschreibung höchstens 65.536 Zeichen, jedes Schema höchstens 65.536 Bytes als JSON. FlowModels führt diese Funktionen nicht aus: Das Modell antwortet mit tool_calls, du führst die Funktion in deinem eigenen System aus und sendest das Ergebnis als Nachricht mit role "tool" zurück. Ob ein Modell Funktionen annimmt, steht in tools aus GET /models; fehlt die Fähigkeit, antwortet die API mit HTTP 400 und unsupported_for_model. Zusammen mit flowai_tools ist das Feld nicht erlaubt und wird mit HTTP 400 und invalid_field_value abgelehnt
tool_choicestring|object
Steuert die Werkzeugwahl: "auto", "none", "required" oder {"type":"function","function":{"name":…}} für genau eine Funktion. Nur zusammen mit tools erlaubt, und der genannte Name muss in tools vorkommen. Ohne Angabe gilt der Standard des Anbieters
parallel_tool_callsboolean
Erlaubt oder verbietet mehrere Funktionsaufrufe in einer Antwort. Nur zusammen mit tools erlaubt. Nicht jedes Modell kennt diesen Schalter; maßgeblich ist parallel_tool_calls aus GET /models, sonst antwortet die API mit HTTP 400 und unsupported_for_model
max_completion_tokensinteger
Dieselbe Angabe wie max_tokens, unter dem Namen der Responses-API. Beide zugleich mit unterschiedlichen Werten werden abgelehnt
stream_optionsobject
Nimmt ausschliesslich include_usage an und setzt stream: true voraus. Mit include_usage: true folgt ein abschliessender Chunk, der den Verbrauch der gestreamten Antwort nennt
userstring
Eigene Kennung des aufrufenden Endnutzers zur Missbrauchsnachverfolgung, bis 128 Zeichen. Diese Kennung ersetzt external_identifier nicht und aktiviert keinen Brain-Kontext
search_domain_filterarray
Beschränkt die native Websuche auf bis zu 20 Domains, etwa ["firma.de"], oder schließt sie mit vorangestelltem Minus aus, etwa ["-reddit.com"]. Entweder nur Freigaben oder nur Ausschlüsse; Domains ohne https:// und ohne Pfad, Subdomains sind eingeschlossen. Das Feld schaltet die Websuche ein und wird zusätzlich abgerechnet. Wie viele Domains das Modell annimmt, steht in GET /models unter capabilities.web_search_domain_filter_max (xAI 5, sonst 20); Modelle ohne Domainfilter wie Gemini lehnen das Feld mit 400 unsupported_for_model ab
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["FLOWMODELS_API_KEY"],
base_url="https://api.flowmodels.one/v1",
)
result = client.chat.completions.create(
model="groq/openai/gpt-oss-120b",
messages=[{"role": "user", "content": "Fasse die Vorteile einer klaren Projektplanung zusammen."}],
max_tokens=512,
stream=True,
)
for chunk in result:
print(chunk.choices[0].delta.content or "", end="", flush=True)
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.FLOWMODELS_API_KEY,
baseURL: "https://api.flowmodels.one/v1",
});
const result = await client.chat.completions.create({
"model": "groq/openai/gpt-oss-120b",
"messages": [
{
"role": "user",
"content": "Fasse die Vorteile einer klaren Projektplanung zusammen."
}
],
"max_tokens": 512,
"stream": true
});
for await (const chunk of result) {
process.stdout.write(chunk.choices?.[0]?.delta?.content ?? "");
}
Einfacher Text steht in input; strukturierte Nachrichten sind ebenfalls möglich. Lies den Text aus output[].content[] mit type: output_text. Ohne Zusatzoption erhältst du synchron JSON. stream: true liefert SSE-Ereignisse. background: true startet einen Hintergrundauftrag und antwortet ohne Streaming mit HTTP 202. Beide Optionen lassen sich kombinieren.
Response-Aufbewahrung
Mit store: true bleiben Response und Ereignisse für 24 Stunden nach Abschluss abrufbar. Im Hintergrund ist Speicherung standardmäßig aktiviert, sonst deaktiviert. background: true darf nicht mit store: false kombiniert werden. Eine nicht gespeicherte Antwort ist nach Abschluss nicht per GET abrufbar. Response-Aufbewahrung ist vom dauerhaften Brain-Gesprächsverlauf getrennt.
Polling und SSE-Fortsetzung
Rufe gespeicherte Antworten unter GET /responses/{response_uuid} ab. Für Ereignisse verwende ?stream=true. Speichere die letzte sequence_number aus einem Ereignis; mit starting_after=N erhältst du ausschließlich spätere Ereignisse. Ein solcher Abruf startet keinen neuen Modellaufruf. Der Cursor ist eine nicht negative Ganzzahl und benötigt stream=true. Abgelaufene, nicht gespeicherte und fremde Responses liefern 404 response_not_found.
Ein unterbrochener Beobachtungsstream beendet einen Hintergrundauftrag nicht. Du kannst ihn erneut beobachten oder über POST /responses/{response_uuid}/cancel abbrechen. Bereits entstandene Kosten bleiben bestehen. Für Ergebnisse per Webhook registriere ein Ziel und sende dessen UUID als webhook_endpoint_id mit.
POST
/v1/responses
Responses
Alternative mit input statt messages, synchron, als SSE oder im Hintergrund. Eine Endnutzerkennung ergänzt optional Brain-Kontext.
Request Body
modelstring
erforderlich
Vollständige Kennung aus GET /models im Format provider/model-id
external_identifierstring
Aktiviert Brain-Kontext für deine stabile Endnutzerkennung mit 1 bis 255 Zeichen; im JSON-Body
inputstring|array
erforderlich
Neue Nutzernachricht als Text oder unterstützte Nachrichtenstruktur
conversationuuid
UUID aus der vorherigen Antwort desselben Endnutzers; für eine neue Unterhaltung weglassen
streamboolean
Antwortereignisse als SSE empfangen; auch mit background kombinierbar
backgroundboolean
Im Hintergrund ausführen; ohne stream folgt HTTP 202 mit Response-ID
storeboolean
Response und Ereignisse für 24 Stunden nach Abschluss abrufbar halten; Standard bei background true, sonst false
webhook_endpoint_iduuid
Registriertes Webhook-Ziel für einen Hintergrundauftrag
max_output_tokensinteger
Obergrenze der Ausgabe, 1 bis 128.000. Ohne Angabe gilt das Maximum des Modells; ist für das Modell keines hinterlegt, greifen 4.096 Tokens. null zählt wie ohne Angabe. OpenAI-Modelle nehmen mindestens 16 Tokens an, ein kleinerer Wert wird mit 400 abgelehnt
context_compressionboolean
Erlaubt, einen zu langen selbst gesendeten Verlauf serverseitig zusammenzufassen; Standard false. Ohne diese Angabe wird ein zu langer Verlauf mit 400 context_length_exceeded abgelehnt statt gekürzt. Die Zusammenfassung ist ein zusätzlicher kostenpflichtiger Modellaufruf und wird in usage.flowai.compression ausgewiesen
reasoning.effortstring
Denktiefe des Modells: none, minimal, low, medium, high, xhigh oder max, auf diesem Endpunkt im Objekt reasoning statt als reasoning_effort. Welche Stufen ein Modell annimmt, steht in capabilities.reasoning_levels aus GET /models. Ohne Angabe gilt der Standard des Anbieters; eine für das Modell unbekannte Stufe wird mit HTTP 400 und unsupported_for_model abgelehnt
web_searchboolean
Schaltet die native Websuche des Anbieters ein. Standard ist aus, weil jede Suche zusätzlich abgerechnet wird. Modelle ohne native Suche lehnen true ab, Modelle mit fest eingebauter Suche (Perplexity, Groq Compound) lehnen false ab, jeweils mit HTTP 400 und unsupported_for_model; maßgeblich sind web_search und web_search_forced aus GET /models
response_formatobject
Ausgabeform wie bei Chat-Completions: {"type":"text"}, {"type":"json_object"} oder {"type":"json_schema","json_schema":{"name":…,"schema":…,"strict":…}}. Die Antwort spiegelt sie als text.format mit flach eingebettetem Schema zurück; ohne Angabe enthält die Antwort kein Feld text
text.formatobject
Alternative Schreibweise der OpenAI-Responses-API, wie sie die offiziellen SDKs senden: {"type":"json_object"} oder {"type":"json_schema","name":…,"schema":…,"strict":…} mit flachem Schema. Wirkt genau wie response_format. Beide Felder zusammen werden mit HTTP 400 abgelehnt, ebenso weitere Schlüssel in text wie verbosity
toolsarray
Deine eigenen Funktionen, in derselben Schreibweise wie bei Chat-Completions: [{"type":"function","function":{"name":…,"parameters":<JSON-Schema>}}]. Die Antwort spiegelt sie in der Responses-Schreibweise mit flachem name zurück; gesendet wird jedoch immer die verschachtelte Form. FlowModels führt die Funktionen nicht aus
tool_choicestring|object
Wie bei Chat-Completions: "auto", "none", "required" oder ein Objekt, das genau eine Funktion nennt. Beide Schreibweisen werden angenommen, {"type":"function","name":…} ebenso wie {"type":"function","function":{"name":…}}
parallel_tool_callsboolean
Erlaubt oder verbietet mehrere Funktionsaufrufe in einer Antwort. Nur zusammen mit tools erlaubt. Nicht jedes Modell kennt diesen Schalter; maßgeblich ist parallel_tool_calls aus GET /models, sonst antwortet die API mit HTTP 400 und unsupported_for_model
stream_optionsobject
Nimmt ausschliesslich include_usage an und setzt stream: true voraus. Mit include_usage: true folgt ein abschliessender Chunk, der den Verbrauch der gestreamten Antwort nennt
userstring
Eigene Kennung des aufrufenden Endnutzers zur Missbrauchsnachverfolgung, bis 128 Zeichen. Diese Kennung ersetzt external_identifier nicht und aktiviert keinen Brain-Kontext
metadataobject
Bis zu 16 Zeichenkettenpaare, die mit der gespeicherten Antwort aufbewahrt und in ihr zurückgegeben werden. Auf Chat-Completions wird das Feld abgelehnt, weil dort nichts gespeichert wird
search_domain_filterarray
Beschränkt die native Websuche auf bis zu 20 Domains, etwa ["firma.de"], oder schließt sie mit vorangestelltem Minus aus, etwa ["-reddit.com"]. Entweder nur Freigaben oder nur Ausschlüsse; Domains ohne https:// und ohne Pfad, Subdomains sind eingeschlossen. Das Feld schaltet die Websuche ein und wird zusätzlich abgerechnet. Wie viele Domains das Modell annimmt, steht in GET /models unter capabilities.web_search_domain_filter_max (xAI 5, sonst 20); Modelle ohne Domainfilter wie Gemini lehnen das Feld mit 400 unsupported_for_model ab
Alternative mit input statt messages, synchron, als SSE oder im Hintergrund. Eine Endnutzerkennung ergänzt optional Brain-Kontext.
Request Body
modelstring
erforderlich
Vollständige Kennung aus GET /models im Format provider/model-id
external_identifierstring
Aktiviert Brain-Kontext für deine stabile Endnutzerkennung mit 1 bis 255 Zeichen; im JSON-Body
inputstring|array
erforderlich
Neue Nutzernachricht als Text oder unterstützte Nachrichtenstruktur
conversationuuid
UUID aus der vorherigen Antwort desselben Endnutzers; für eine neue Unterhaltung weglassen
streamboolean
Antwortereignisse als SSE empfangen; auch mit background kombinierbar
backgroundboolean
Im Hintergrund ausführen; ohne stream folgt HTTP 202 mit Response-ID
storeboolean
Response und Ereignisse für 24 Stunden nach Abschluss abrufbar halten; Standard bei background true, sonst false
webhook_endpoint_iduuid
Registriertes Webhook-Ziel für einen Hintergrundauftrag
max_output_tokensinteger
Obergrenze der Ausgabe, 1 bis 128.000. Ohne Angabe gilt das Maximum des Modells; ist für das Modell keines hinterlegt, greifen 4.096 Tokens. null zählt wie ohne Angabe. OpenAI-Modelle nehmen mindestens 16 Tokens an, ein kleinerer Wert wird mit 400 abgelehnt
context_compressionboolean
Erlaubt, einen zu langen selbst gesendeten Verlauf serverseitig zusammenzufassen; Standard false. Ohne diese Angabe wird ein zu langer Verlauf mit 400 context_length_exceeded abgelehnt statt gekürzt. Die Zusammenfassung ist ein zusätzlicher kostenpflichtiger Modellaufruf und wird in usage.flowai.compression ausgewiesen
reasoning.effortstring
Denktiefe des Modells: none, minimal, low, medium, high, xhigh oder max, auf diesem Endpunkt im Objekt reasoning statt als reasoning_effort. Welche Stufen ein Modell annimmt, steht in capabilities.reasoning_levels aus GET /models. Ohne Angabe gilt der Standard des Anbieters; eine für das Modell unbekannte Stufe wird mit HTTP 400 und unsupported_for_model abgelehnt
web_searchboolean
Schaltet die native Websuche des Anbieters ein. Standard ist aus, weil jede Suche zusätzlich abgerechnet wird. Modelle ohne native Suche lehnen true ab, Modelle mit fest eingebauter Suche (Perplexity, Groq Compound) lehnen false ab, jeweils mit HTTP 400 und unsupported_for_model; maßgeblich sind web_search und web_search_forced aus GET /models
response_formatobject
Ausgabeform wie bei Chat-Completions: {"type":"text"}, {"type":"json_object"} oder {"type":"json_schema","json_schema":{"name":…,"schema":…,"strict":…}}. Die Antwort spiegelt sie als text.format mit flach eingebettetem Schema zurück; ohne Angabe enthält die Antwort kein Feld text
text.formatobject
Alternative Schreibweise der OpenAI-Responses-API, wie sie die offiziellen SDKs senden: {"type":"json_object"} oder {"type":"json_schema","name":…,"schema":…,"strict":…} mit flachem Schema. Wirkt genau wie response_format. Beide Felder zusammen werden mit HTTP 400 abgelehnt, ebenso weitere Schlüssel in text wie verbosity
toolsarray
Deine eigenen Funktionen, in derselben Schreibweise wie bei Chat-Completions: [{"type":"function","function":{"name":…,"parameters":<JSON-Schema>}}]. Die Antwort spiegelt sie in der Responses-Schreibweise mit flachem name zurück; gesendet wird jedoch immer die verschachtelte Form. FlowModels führt die Funktionen nicht aus
tool_choicestring|object
Wie bei Chat-Completions: "auto", "none", "required" oder ein Objekt, das genau eine Funktion nennt. Beide Schreibweisen werden angenommen, {"type":"function","name":…} ebenso wie {"type":"function","function":{"name":…}}
parallel_tool_callsboolean
Erlaubt oder verbietet mehrere Funktionsaufrufe in einer Antwort. Nur zusammen mit tools erlaubt. Nicht jedes Modell kennt diesen Schalter; maßgeblich ist parallel_tool_calls aus GET /models, sonst antwortet die API mit HTTP 400 und unsupported_for_model
stream_optionsobject
Nimmt ausschliesslich include_usage an und setzt stream: true voraus. Mit include_usage: true folgt ein abschliessender Chunk, der den Verbrauch der gestreamten Antwort nennt
userstring
Eigene Kennung des aufrufenden Endnutzers zur Missbrauchsnachverfolgung, bis 128 Zeichen. Diese Kennung ersetzt external_identifier nicht und aktiviert keinen Brain-Kontext
metadataobject
Bis zu 16 Zeichenkettenpaare, die mit der gespeicherten Antwort aufbewahrt und in ihr zurückgegeben werden. Auf Chat-Completions wird das Feld abgelehnt, weil dort nichts gespeichert wird
search_domain_filterarray
Beschränkt die native Websuche auf bis zu 20 Domains, etwa ["firma.de"], oder schließt sie mit vorangestelltem Minus aus, etwa ["-reddit.com"]. Entweder nur Freigaben oder nur Ausschlüsse; Domains ohne https:// und ohne Pfad, Subdomains sind eingeschlossen. Das Feld schaltet die Websuche ein und wird zusätzlich abgerechnet. Wie viele Domains das Modell annimmt, steht in GET /models unter capabilities.web_search_domain_filter_max (xAI 5, sonst 20); Modelle ohne Domainfilter wie Gemini lehnen das Feld mit 400 unsupported_for_model ab
curl -N -X POST "https://api.flowmodels.one/v1/responses" -H "Authorization: Bearer $FLOWMODELS_API_KEY" -H "Accept: text/event-stream" -H "Content-Type: application/json" --data '{"model":"groq/openai/gpt-oss-120b","external_identifier":"customer-42","input":"Fasse die Vorteile einer klaren Projektplanung zusammen.","max_output_tokens":512,"stream":true,"store":true}'
import os
from urllib.request import Request, urlopen
request = Request("https://api.flowmodels.one/v1/responses", data="{\"model\":\"groq/openai/gpt-oss-120b\",\"external_identifier\":\"customer-42\",\"input\":\"Fasse die Vorteile einer klaren Projektplanung zusammen.\",\"max_output_tokens\":512,\"stream\":true,\"store\":true}".encode("utf-8"), headers={"Authorization": f"Bearer {os.environ['FLOWMODELS_API_KEY']}", "Content-Type": "application/json", "Accept": "text/event-stream"}, method="POST")
with urlopen(request) as response:
for line in response:
print(line.decode('utf-8'), end='')
const response = await fetch("https://api.flowmodels.one/v1/responses", {"method":"POST","headers":{"Authorization":`Bearer ${process.env.FLOWMODELS_API_KEY}`,"Content-Type":"application/json","Accept":"text/event-stream"},"body":"{\"model\":\"groq/openai/gpt-oss-120b\",\"external_identifier\":\"customer-42\",\"input\":\"Fasse die Vorteile einer klaren Projektplanung zusammen.\",\"max_output_tokens\":512,\"stream\":true,\"store\":true}"});
if (!response.ok) throw new Error(await response.text());
const reader = response.body.getReader();
const decoder = new TextDecoder();
while (true) {
const { done, value } = await reader.read();
if (done) break;
process.stdout.write(decoder.decode(value, { stream: true }));
}
Startet einen gespeicherten Hintergrundauftrag und antwortet mit HTTP 202. Verwende die Response-ID für Polling, SSE und Abbruch.
Request Body
modelstring
erforderlich
Vollständige Kennung aus GET /models im Format provider/model-id
external_identifierstring
Aktiviert Brain-Kontext für deine stabile Endnutzerkennung mit 1 bis 255 Zeichen; im JSON-Body
inputstring|array
erforderlich
Neue Nutzernachricht als Text oder unterstützte Nachrichtenstruktur
conversationuuid
UUID aus der vorherigen Antwort desselben Endnutzers; für eine neue Unterhaltung weglassen
streamboolean
Antwortereignisse als SSE empfangen; auch mit background kombinierbar
backgroundboolean
Im Hintergrund ausführen; ohne stream folgt HTTP 202 mit Response-ID
storeboolean
Response und Ereignisse für 24 Stunden nach Abschluss abrufbar halten; Standard bei background true, sonst false
webhook_endpoint_iduuid
Registriertes Webhook-Ziel für einen Hintergrundauftrag
max_output_tokensinteger
Obergrenze der Ausgabe, 1 bis 128.000. Ohne Angabe gilt das Maximum des Modells; ist für das Modell keines hinterlegt, greifen 4.096 Tokens. null zählt wie ohne Angabe. OpenAI-Modelle nehmen mindestens 16 Tokens an, ein kleinerer Wert wird mit 400 abgelehnt
context_compressionboolean
Erlaubt, einen zu langen selbst gesendeten Verlauf serverseitig zusammenzufassen; Standard false. Ohne diese Angabe wird ein zu langer Verlauf mit 400 context_length_exceeded abgelehnt statt gekürzt. Die Zusammenfassung ist ein zusätzlicher kostenpflichtiger Modellaufruf und wird in usage.flowai.compression ausgewiesen
reasoning.effortstring
Denktiefe des Modells: none, minimal, low, medium, high, xhigh oder max, auf diesem Endpunkt im Objekt reasoning statt als reasoning_effort. Welche Stufen ein Modell annimmt, steht in capabilities.reasoning_levels aus GET /models. Ohne Angabe gilt der Standard des Anbieters; eine für das Modell unbekannte Stufe wird mit HTTP 400 und unsupported_for_model abgelehnt
web_searchboolean
Schaltet die native Websuche des Anbieters ein. Standard ist aus, weil jede Suche zusätzlich abgerechnet wird. Modelle ohne native Suche lehnen true ab, Modelle mit fest eingebauter Suche (Perplexity, Groq Compound) lehnen false ab, jeweils mit HTTP 400 und unsupported_for_model; maßgeblich sind web_search und web_search_forced aus GET /models
response_formatobject
Ausgabeform wie bei Chat-Completions: {"type":"text"}, {"type":"json_object"} oder {"type":"json_schema","json_schema":{"name":…,"schema":…,"strict":…}}. Die Antwort spiegelt sie als text.format mit flach eingebettetem Schema zurück; ohne Angabe enthält die Antwort kein Feld text
text.formatobject
Alternative Schreibweise der OpenAI-Responses-API, wie sie die offiziellen SDKs senden: {"type":"json_object"} oder {"type":"json_schema","name":…,"schema":…,"strict":…} mit flachem Schema. Wirkt genau wie response_format. Beide Felder zusammen werden mit HTTP 400 abgelehnt, ebenso weitere Schlüssel in text wie verbosity
toolsarray
Deine eigenen Funktionen, in derselben Schreibweise wie bei Chat-Completions: [{"type":"function","function":{"name":…,"parameters":<JSON-Schema>}}]. Die Antwort spiegelt sie in der Responses-Schreibweise mit flachem name zurück; gesendet wird jedoch immer die verschachtelte Form. FlowModels führt die Funktionen nicht aus
tool_choicestring|object
Wie bei Chat-Completions: "auto", "none", "required" oder ein Objekt, das genau eine Funktion nennt. Beide Schreibweisen werden angenommen, {"type":"function","name":…} ebenso wie {"type":"function","function":{"name":…}}
parallel_tool_callsboolean
Erlaubt oder verbietet mehrere Funktionsaufrufe in einer Antwort. Nur zusammen mit tools erlaubt. Nicht jedes Modell kennt diesen Schalter; maßgeblich ist parallel_tool_calls aus GET /models, sonst antwortet die API mit HTTP 400 und unsupported_for_model
stream_optionsobject
Nimmt ausschliesslich include_usage an und setzt stream: true voraus. Mit include_usage: true folgt ein abschliessender Chunk, der den Verbrauch der gestreamten Antwort nennt
userstring
Eigene Kennung des aufrufenden Endnutzers zur Missbrauchsnachverfolgung, bis 128 Zeichen. Diese Kennung ersetzt external_identifier nicht und aktiviert keinen Brain-Kontext
metadataobject
Bis zu 16 Zeichenkettenpaare, die mit der gespeicherten Antwort aufbewahrt und in ihr zurückgegeben werden. Auf Chat-Completions wird das Feld abgelehnt, weil dort nichts gespeichert wird
search_domain_filterarray
Beschränkt die native Websuche auf bis zu 20 Domains, etwa ["firma.de"], oder schließt sie mit vorangestelltem Minus aus, etwa ["-reddit.com"]. Entweder nur Freigaben oder nur Ausschlüsse; Domains ohne https:// und ohne Pfad, Subdomains sind eingeschlossen. Das Feld schaltet die Websuche ein und wird zusätzlich abgerechnet. Wie viele Domains das Modell annimmt, steht in GET /models unter capabilities.web_search_domain_filter_max (xAI 5, sonst 20); Modelle ohne Domainfilter wie Gemini lehnen das Feld mit 400 unsupported_for_model ab
Kombiniert background und stream. Der Worker läuft bei einer Unterbrechung des Beobachtungsstreams weiter.
Request Body
modelstring
erforderlich
Vollständige Kennung aus GET /models im Format provider/model-id
external_identifierstring
Aktiviert Brain-Kontext für deine stabile Endnutzerkennung mit 1 bis 255 Zeichen; im JSON-Body
inputstring|array
erforderlich
Neue Nutzernachricht als Text oder unterstützte Nachrichtenstruktur
conversationuuid
UUID aus der vorherigen Antwort desselben Endnutzers; für eine neue Unterhaltung weglassen
streamboolean
Antwortereignisse als SSE empfangen; auch mit background kombinierbar
backgroundboolean
Im Hintergrund ausführen; ohne stream folgt HTTP 202 mit Response-ID
storeboolean
Response und Ereignisse für 24 Stunden nach Abschluss abrufbar halten; Standard bei background true, sonst false
webhook_endpoint_iduuid
Registriertes Webhook-Ziel für einen Hintergrundauftrag
max_output_tokensinteger
Obergrenze der Ausgabe, 1 bis 128.000. Ohne Angabe gilt das Maximum des Modells; ist für das Modell keines hinterlegt, greifen 4.096 Tokens. null zählt wie ohne Angabe. OpenAI-Modelle nehmen mindestens 16 Tokens an, ein kleinerer Wert wird mit 400 abgelehnt
context_compressionboolean
Erlaubt, einen zu langen selbst gesendeten Verlauf serverseitig zusammenzufassen; Standard false. Ohne diese Angabe wird ein zu langer Verlauf mit 400 context_length_exceeded abgelehnt statt gekürzt. Die Zusammenfassung ist ein zusätzlicher kostenpflichtiger Modellaufruf und wird in usage.flowai.compression ausgewiesen
reasoning.effortstring
Denktiefe des Modells: none, minimal, low, medium, high, xhigh oder max, auf diesem Endpunkt im Objekt reasoning statt als reasoning_effort. Welche Stufen ein Modell annimmt, steht in capabilities.reasoning_levels aus GET /models. Ohne Angabe gilt der Standard des Anbieters; eine für das Modell unbekannte Stufe wird mit HTTP 400 und unsupported_for_model abgelehnt
web_searchboolean
Schaltet die native Websuche des Anbieters ein. Standard ist aus, weil jede Suche zusätzlich abgerechnet wird. Modelle ohne native Suche lehnen true ab, Modelle mit fest eingebauter Suche (Perplexity, Groq Compound) lehnen false ab, jeweils mit HTTP 400 und unsupported_for_model; maßgeblich sind web_search und web_search_forced aus GET /models
response_formatobject
Ausgabeform wie bei Chat-Completions: {"type":"text"}, {"type":"json_object"} oder {"type":"json_schema","json_schema":{"name":…,"schema":…,"strict":…}}. Die Antwort spiegelt sie als text.format mit flach eingebettetem Schema zurück; ohne Angabe enthält die Antwort kein Feld text
text.formatobject
Alternative Schreibweise der OpenAI-Responses-API, wie sie die offiziellen SDKs senden: {"type":"json_object"} oder {"type":"json_schema","name":…,"schema":…,"strict":…} mit flachem Schema. Wirkt genau wie response_format. Beide Felder zusammen werden mit HTTP 400 abgelehnt, ebenso weitere Schlüssel in text wie verbosity
toolsarray
Deine eigenen Funktionen, in derselben Schreibweise wie bei Chat-Completions: [{"type":"function","function":{"name":…,"parameters":<JSON-Schema>}}]. Die Antwort spiegelt sie in der Responses-Schreibweise mit flachem name zurück; gesendet wird jedoch immer die verschachtelte Form. FlowModels führt die Funktionen nicht aus
tool_choicestring|object
Wie bei Chat-Completions: "auto", "none", "required" oder ein Objekt, das genau eine Funktion nennt. Beide Schreibweisen werden angenommen, {"type":"function","name":…} ebenso wie {"type":"function","function":{"name":…}}
parallel_tool_callsboolean
Erlaubt oder verbietet mehrere Funktionsaufrufe in einer Antwort. Nur zusammen mit tools erlaubt. Nicht jedes Modell kennt diesen Schalter; maßgeblich ist parallel_tool_calls aus GET /models, sonst antwortet die API mit HTTP 400 und unsupported_for_model
stream_optionsobject
Nimmt ausschliesslich include_usage an und setzt stream: true voraus. Mit include_usage: true folgt ein abschliessender Chunk, der den Verbrauch der gestreamten Antwort nennt
userstring
Eigene Kennung des aufrufenden Endnutzers zur Missbrauchsnachverfolgung, bis 128 Zeichen. Diese Kennung ersetzt external_identifier nicht und aktiviert keinen Brain-Kontext
metadataobject
Bis zu 16 Zeichenkettenpaare, die mit der gespeicherten Antwort aufbewahrt und in ihr zurückgegeben werden. Auf Chat-Completions wird das Feld abgelehnt, weil dort nichts gespeichert wird
search_domain_filterarray
Beschränkt die native Websuche auf bis zu 20 Domains, etwa ["firma.de"], oder schließt sie mit vorangestelltem Minus aus, etwa ["-reddit.com"]. Entweder nur Freigaben oder nur Ausschlüsse; Domains ohne https:// und ohne Pfad, Subdomains sind eingeschlossen. Das Feld schaltet die Websuche ein und wird zusätzlich abgerechnet. Wie viele Domains das Modell annimmt, steht in GET /models unter capabilities.web_search_domain_filter_max (xAI 5, sonst 20); Modelle ohne Domainfilter wie Gemini lehnen das Feld mit 400 unsupported_for_model ab
curl -N -X POST "https://api.flowmodels.one/v1/responses" -H "Authorization: Bearer $FLOWMODELS_API_KEY" -H "Accept: text/event-stream" -H "Content-Type: application/json" --data '{"model":"groq/openai/gpt-oss-120b","external_identifier":"customer-42","input":"Fasse die Vorteile einer klaren Projektplanung zusammen.","max_output_tokens":512,"stream":true,"store":true,"background":true}'
import os
from urllib.request import Request, urlopen
request = Request("https://api.flowmodels.one/v1/responses", data="{\"model\":\"groq/openai/gpt-oss-120b\",\"external_identifier\":\"customer-42\",\"input\":\"Fasse die Vorteile einer klaren Projektplanung zusammen.\",\"max_output_tokens\":512,\"stream\":true,\"store\":true,\"background\":true}".encode("utf-8"), headers={"Authorization": f"Bearer {os.environ['FLOWMODELS_API_KEY']}", "Content-Type": "application/json", "Accept": "text/event-stream"}, method="POST")
with urlopen(request) as response:
for line in response:
print(line.decode('utf-8'), end='')
const response = await fetch("https://api.flowmodels.one/v1/responses", {"method":"POST","headers":{"Authorization":`Bearer ${process.env.FLOWMODELS_API_KEY}`,"Content-Type":"application/json","Accept":"text/event-stream"},"body":"{\"model\":\"groq/openai/gpt-oss-120b\",\"external_identifier\":\"customer-42\",\"input\":\"Fasse die Vorteile einer klaren Projektplanung zusammen.\",\"max_output_tokens\":512,\"stream\":true,\"store\":true,\"background\":true}"});
if (!response.ok) throw new Error(await response.text());
const reader = response.body.getReader();
const decoder = new TextDecoder();
while (true) {
const { done, value } = await reader.read();
if (done) break;
process.stdout.write(decoder.decode(value, { stream: true }));
}
import os
from urllib.request import Request, urlopen
request = Request("https://api.flowmodels.one/v1/responses/{response_uuid}?stream=true&starting_after=4", data=None, headers={"Authorization": f"Bearer {os.environ['FLOWMODELS_API_KEY']}", "Content-Type": "application/json", "Accept": "text/event-stream"}, method="GET")
with urlopen(request) as response:
for line in response:
print(line.decode('utf-8'), end='')
const response = await fetch("https://api.flowmodels.one/v1/responses/{response_uuid}?stream=true&starting_after=4", {"method":"GET","headers":{"Authorization":`Bearer ${process.env.FLOWMODELS_API_KEY}`,"Content-Type":"application/json","Accept":"text/event-stream"}});
if (!response.ok) throw new Error(await response.text());
const reader = response.body.getReader();
const decoder = new TextDecoder();
while (true) {
const { done, value } = await reader.read();
if (done) break;
process.stdout.write(decoder.decode(value, { stream: true }));
}
Sende beim nächsten Aufruf dieselbe external_identifier, die zurückgegebene conversation-UUID und nur die neuen Nachrichten. Der vorhandene Verlauf wird serverseitig ergänzt. Wenn du den gesamten alten Verlauf noch einmal mitsendest, entsteht doppelter Kontext.
{
"model": "groq/openai/gpt-oss-120b",
"external_identifier": "customer-42",
"conversation": "018f1234-5678-7abc-9def-0123456789ab",
"messages": [{"role": "user", "content": "Gib mir dazu drei konkrete nächste Schritte."}]
}
Eine Anfrage ohne conversation beginnt eine neue Unterhaltung. Eine unbekannte oder zu einem anderen Workspace beziehungsweise Endnutzer gehörende UUID ergibt 404 conversation_not_found. Für dieselbe Unterhaltung darf nur ein Aufruf gleichzeitig laufen; konkurrierende Aufrufe erhalten 409 conversation_in_progress.
Verlauf, Dateien und Erinnerungen
Brain ergänzt den gespeicherten Gesprächsverlauf und relevante Erinnerungen sowie Dateiabschnitte derselben Person. Der Kontext wird an das Tokenbudget des Modells angepasst. Lange Verläufe werden schrittweise zusammengefasst; auch diese Modellaufrufe gehören zum kostenpflichtigen Verbrauch. Fehlerhafte Zusammenfassungen ersetzen keinen gültigen gespeicherten Stand. Ohne Endnutzerkennung verwaltet der Client den Verlauf und es wird kein persönlicher Brain-Kontext gesucht.
Endnutzerverwaltung
Löschung mit Aufbewahrungspflicht
Die Löschung entfernt persönliche Arbeitsdaten. Abrechnungs- und Verbrauchszeilen bleiben aus Aufbewahrungsgründen erhalten.
Externe Kennung und öffentliche UUID
external_identifier ist deine eigene stabile Zeichenfolge, zum Beispiel customer-42. Damit ordnest du Anfragen innerhalb deines Workspace einem Endnutzer zu. Auch numerische Kennungen müssen als JSON-Zeichenfolge gesendet werden. Der erste Inferenzaufruf ohne conversation legt einen unbekannten Endnutzer automatisch an.
Mit POST /end-users kannst du den Endnutzer vorher anlegen oder auflösen. Die zurückgegebene id ist die öffentliche UUID für Verwaltungs- und Datei-Endpunkte. Diese UUID ist von deiner externen Kennung und von der conversation-UUID zu unterscheiden.
Verlaufsverdichtung
Mit external_identifier liegt der Verlauf bei uns. Wird er länger als das Eingabefenster des Modells, fassen wir die älteren Turns zusammen und speichern diese Zusammenfassung. Jeder Turn wird dadurch genau einmal verdichtet und genau einmal bezahlt. Eine feste Zahl der jüngsten gespeicherten Turns bleibt dabei immer im Wortlaut erhalten; alles davor erreicht das Modell ausschließlich über die Zusammenfassung. Verloren geht nichts: ein Turn verlässt den Wortlaut erst, nachdem die Zusammenfassung ihn aufgenommen hat.
Ohne external_identifier gehört der Verlauf dir, und wir fassen nichts von selbst zusammen. Passt der gesendete Verlauf nicht in das Eingabefenster, antworten wir mit 400 context_length_exceeded; die Meldung nennt max_input_tokens und estimated_input_tokens. Sende dann weniger Nachrichten, oder setze context_compression: true und erlaube damit ausdrücklich die Verdichtung. Diese Verdichtung ist ein zusätzlicher kostenpflichtiger Modellaufruf je Anfrage und wird im Antwortblock usage.flowai.compression mit calls, input_tokens, output_tokens und cost_micro_eur ausgewiesen. Ohne Verdichtung fehlt das Feld.
Metadaten und automatische Erinnerungen
Metadaten enthalten höchstens 50 Einträge mit Schlüsseln bis 64 Zeichen und Zeichenfolgen bis 1.000 Zeichen oder null als Wert. Automatische Erinnerungsextraktion ist bei neuen Endnutzern standardmäßig aktiviert, sobald du Brain mit external_identifier verwendest. Ein zusätzliches Opt-in ist nicht erforderlich. Ohne externe Kennung wird kein Brain verwendet. Deaktiviere die Extraktion bei Bedarf mit PATCH /end-users/{end_user_uuid} und memory_extraction_enabled: false. Bereits ausdrücklich deaktivierte Einstellungen bleiben erhalten.
Endnutzerdaten löschen
DELETE /end-users/{end_user_uuid} entfernt die persönlichen Arbeitsdaten dieser Person aus der API-Nutzung. Private Dateiobjekte werden anschließend im Hintergrund gelöscht; vorübergehende Speicherfehler werden erneut versucht. deleted: true bestätigt daher nicht den bereits abgeschlossenen physischen Löschvorgang aller Objekte. Abrechnungs- und Verbrauchsdaten bleiben erhalten. Unbekannte und fremde UUIDs liefern dieselbe Antwort mit 404 end_user_not_found.
Löschbeleg abrufen
GET /end_users/{end_user_uuid}/erasures listet die Löschvorgänge zu dieser Kennung, GET /end_users/{end_user_uuid}/erasures/{run_uuid} liefert einen einzelnen Beleg. Beide bleiben nach der Löschung abrufbar, denn genau dann brauchst du den Nachweis. status nennt den Stand, requested_at den Zeitpunkt deiner Anforderung und completed_at den Abschluss oder null, solange Objekte im Hintergrund entfernt werden.
manifest_summary.resources nennt je Datenart die Anzahl vor und nach dem Vorgang. Der Beleg enthält ausschließlich Zahlen: keine Texte, keine Dateinamen und keine Kennungen. Datenarten ohne öffentliche Bezeichnung werden nicht ausgewiesen.
GET
/v1/end-users
Endnutzer auflisten
Listet die Endnutzer des authentifizierten Workspace mit UUID-Cursor auf.
Lege den Endnutzer an oder löse ihn über POST /end-users auf. Verwende seine öffentliche UUID für POST /end_users/{end_user_uuid}/files. Beachte den Unterstrich in end_users; die Endnutzerverwaltung verwendet dagegen end-users.
Sende die Datei als multipart/form-data mit purpose=user_data. Unterstützt werden PDF, DOCX, XLSX, TXT, Markdown und CSV. Die Standardgrenzen betragen 32 MiB pro Datei, 100 Dateien pro Endnutzer und 5 GiB pro Workspace. Für Multipart-Anfragen erzeugt dein HTTP-Client den Content-Type einschließlich Boundary.
Verarbeitung erfolgt im Hintergrund
Ein erfolgreicher Upload antwortet mit HTTP 201 und status: pending. Erst nach Extraktion und Indizierung stehen passende Textstellen für spätere Anfragen desselben Endnutzers zur Verfügung. Der Upload bestätigt noch nicht, dass die Datei bereits abrufbarer Gesprächskontext ist. Vorübergehende Verarbeitungsfehler werden erneut versucht; nicht lesbarer Dokumentinhalt kann dauerhaft fehlschlagen.
Auflisten, prüfen, einzeln entfernen
GET /end_users/{end_user_uuid}/files listet die Dateien dieser Person, neueste zuerst, seitenweise über limit und after. status nennt den Stand der Verarbeitung. DELETE /end_users/{end_user_uuid}/files/{file_uuid} entfernt eine einzelne Datei samt der daraus gewonnenen Textabschnitte; die Löschung der gesamten Person ist dafür nicht mehr nötig. Die Datei-ID dieses Uploads gehört weiterhin nicht zur allgemeinen /files-Verwaltung.
Nach dem Löschen verbleibt ein inhaltsfreier Eintrag ohne Dateinamen und ohne Objekt, damit der bereits genutzte Speicher abrechenbar bleibt. Er erscheint in keiner Liste. Unbekannte Dateien, Dateien einer anderen Person und Dateien eines anderen Workspace liefern dieselbe Antwort mit 404 file_not_found.
POST
/v1/end_users/{end_user_uuid}/files
Endnutzerdatei hochladen
Speichert eine Textdatei für den Endnutzer und startet ihre Verarbeitung. Verwende multipart/form-data.
Request Body
filefile
erforderlich
Unterstützte Text- oder Dokumentdatei mit Dateiname bis 255 Zeichen
purposestring
erforderlich
Pflichtwert user_data; andere Zwecke werden abgelehnt
Sende Uploads als multipart/form-data. Zulässige Zwecke sind user_data und vision. Eine automatische Aufbewahrungsfrist wird nicht angeboten; nicht mehr benötigte Dateien müssen ausdrücklich gelöscht werden.
Metadaten und Inhalt
Der Einzelabruf liefert nur Metadaten. Die gespeicherten Bytes stehen ausschließlich über den gesonderten Inhaltsendpunkt bereit.
POST
/v1/files
Datei hochladen
Speichert eine Datei für spätere Anfragen. Verwende multipart/form-data.
Diese Endpunkte gehören zur Brain-Funktion von FlowModels und benötigen einen FlowModels-Schlüssel.
Alle Aufrufe binden eine Erinnerung über external_identifier an genau einen Endnutzer. Änderungen verwenden revision zur optimistischen Konflikterkennung.
Auflisten oder suchen
GET /memories beantwortet zwei Fragen über dieselben Einträge. Ohnequery erhältst du die Erinnerungen dieser Person chronologisch absteigend, seitenweise über limit und after; dieser Weg ruft kein Modell auf und kostet nichts. Mitquery läuft die Ähnlichkeitssuche, die den Suchtext einbettet und daher zum kostenpflichtigen Verbrauch zählt.
Ein Suchergebnis ist eine Rangfolge und keine Seite: die Suche liefert deshalb has_more: false und last_id: null und bietet keinen Cursor an. Ein after-Wert, der nicht aus einer vorherigen Seite stammt, wird mit 400 invalid_cursor abgelehnt und niemals als leere Seite beantwortet.
Kontext für spätere Antworten
Gespeicherte Erinnerungen werden innerhalb desselben Workspace und Endnutzers als relevanter Kontext herangezogen. Das manuelle Anlegen einer Erinnerung benötigt keine aktivierte automatische Extraktion. Bewahre die zurückgegebene revision auf und sende sie beim Ändern mit. Bei 409 memory_revision_conflict musst du den aktuellen Stand erneut abrufen und die Änderung abgleichen.
POST
/v1/memories
Erinnerung anlegen
Speichert eine persönliche Erinnerung für einen Endnutzer.
Das Signatur-Secret wird ausschließlich beim Anlegen zurückgegeben. Speichere es sicher und veröffentliche es nicht.
Ziele und Signaturen
Webhook-Ziele müssen öffentlich erreichbare HTTPS-Adressen sein. Die API prüft Adressen beim Speichern und erneut vor jeder Zustellung. Registriere mindestens einen unterstützten Ereignistyp.
Zustellungen prüfen
Der Zustellungsverlauf zeigt Status, Versuche und Fehlerart. Zulässige Statusfilter sind pending, delivered, failed und exhausted.
Unterstützte Ereignistypen
Neben den vier Abschlussereignissen eines Hintergrundauftrags (response.completed, response.failed, response.cancelled, response.incomplete) kannst du vier weitere Typen abonnieren: credit.threshold beim Erreichen einer deiner Warnschwellen in Euro (data.metric ist balance_floor, wenn der verfügbare Betrag unter die Schwelle gefallen ist, oder spend_month, wenn der Monatsverbrauch sie erreicht hat; data.threshold_eur nennt den Schwellenbetrag als Dezimalzeichenkette, zum Beispiel "50.00"), credit.topup_failed bei einer fehlgeschlagenen Aufladung, webhook_endpoint.deactivated wenn ein Ziel nach wiederholten Fehlversuchen abgeschaltet wurde, und webhook.test für die selbst ausgelöste Testzustellung. Für Videogenerierungen gibt es zusätzlich video.completed, video.failed und video.cancelled. Jede Zustellung hat denselben Aufbau: id, type, created_at und data. webhook_endpoint.deactivated geht bewusst an alle übrigen aktiven Ziele des Workspace, niemals an das gerade abgeschaltete: dieses hat soeben bewiesen, dass es nichts empfangen kann.
Secret wechseln ohne Zustellungslücke
Beim Wechsel bleibt das bisherige Secret bis zum Zeitpunkt aus secondary_secret_expires_at gültig. In diesem Zeitfenster enthält der Kopfzeilenwert webhook-signature zwei durch ein Leerzeichen getrennte Werte der Form v1,<signature>, je einen pro Secret. Prüfe alle Werte und akzeptiere die Zustellung beim ersten Treffer. Nach Ablauf des Fensters wird nur noch mit dem neuen Secret signiert. Das Wechseln des Secrets benötigt einen Verwaltungsschlüssel; ein Inferenzschlüssel erhält 403 insufficient_key_scope.
Signatur prüfen
Jede Zustellung trägt die Header webhook-id, webhook-timestamp und webhook-signature. Die Signatur ist ein HMAC-SHA256 über {webhook-id}.{webhook-timestamp}.{Body}, Base64-kodiert mit dem Präfix v1,. Das Secret ist eine zufällige Zeichenfolge aus 48 Zeichen ohne Präfix. Verwende es so, wie du es bekommen hast: als Text, nicht Base64-dekodiert. Bibliotheken für Standard Webhooks dekodieren Secrets im Format whsec_ vor dem Prüfen und kommen deshalb zu einem anderen Ergebnis. Berechne den HMAC deshalb selbst über den unveränderten Body und vergleiche in konstanter Zeit.
POST
/v1/webhook_endpoints
Webhook anlegen
Registriert ein HTTPS-Ziel und gibt das Signatur-Secret einmalig zurück.
FlowModels benötigt kein Abonnement. Neue Teams starten mit 0 € im Prepaid-Modus. Lade im FlowModels-Dashboard mindestens 20 € auf. Der Aufladebetrag ist der Endbetrag, ohne zusätzliche Steueraufschläge. Kontowerte werden als ganze Micro-EUR geliefert: Eine Million Micro-EUR entsprechen einem Euro.
Vor kostenpflichtiger Verarbeitung werden Mittel reserviert. Danach wird der tatsächliche Verbrauch einschließlich Gesprächskontext, Retrieval und erforderlicher Zusammenfassungen abgerechnet. Verwende usage.cost und usage.currency für den Endkundenbetrag in Euro. Fehlende Preise dürfen nicht als kostenloser Verbrauch interpretiert werden.
Wurde für eine Anfrage Verlauf verdichtet, weist usage.flowai.compression diesen Anteil gesondert aus: calls die Zahl der Zusammenfassungsaufrufe, input_tokens und output_tokens deren Tokens sowie cost_micro_eur deren Kosten in ganzen Micro-EUR. Dieser Betrag steckt bereits in usage.cost; er wird zusätzlich einzeln genannt, damit ein unerwartet hoher Betrag aus der Antwort selbst erklärbar ist. Ohne Verdichtung fehlt das Feld vollständig.
Für gespeicherte Brain-Dateien fällt derzeit keine zusätzliche monatliche Speichergebühr an. Kostenpflichtige Modellverarbeitung, etwa Embeddings und Bildanalyse beim Verarbeiten einer Datei, wird als Modellverbrauch abgerechnet. Die Dateigrößen- und Teamgrenzen gelten weiterhin.
Postpaid nur nach Freischaltung
Nur die Administration kann Postpaid aktivieren. Bei der ersten Freischaltung sind 50 € Kreditrahmen voreingestellt; die Administration kann diesen Betrag pro Team ändern. Guthaben wird zuerst verwendet. Die Monatsrechnung enthält ausschließlich den noch nicht durch Guthaben gedeckten Verbrauch. Offene Forderungen und laufende Reservierungen verringern den nutzbaren Kreditrahmen.
Automatische Aufladung
Automatisches Aufladen ist standardmäßig ausgeschaltet. Aktiviere es ausdrücklich im Modul und wähle eine verifizierte, zum Team gehörende Karte. Die Guthabengrenze beträgt mindestens 5 €, der Aufladebetrag mindestens 20 €. Du kannst die Zustimmung jederzeit widerrufen. Eine Aufladung ändert kein monatliches Schlüssellimit.
Getrennte Schlüssel und Verbrauchsdaten
Erstelle unter FlowModels → API-Schlüssel einen Schlüssel mit der Berechtigung „KI nutzen“ oder „Schlüssel verwalten“. Diese Schlüssel sind dauerhaft FlowModels und einem Abrechnungsteam zugeordnet. Bestehende FlowSuite-Schlüssel werden nicht umgewandelt. Ein Schlüssel mit „Schlüssel verwalten“ kann über /api/user/api-keys auf creativeskyline.de, nicht unter der Basis-URL, nur Schlüssel desselben Produkts verwalten; ohne explizites kind entsteht auch dort ein Schlüssel mit „Schlüssel verwalten“. Modellaufrufe benötigen kind: inference.
GET /credits liefert das EUR-Konto; available_micro_eur ist verfügbares Guthaben, spendable_micro_eur berücksichtigt zusätzlich den freigeschalteten Kreditrahmen. reserved_oldest_at nennt den Zeitpunkt der ältesten noch offenen Reservierung oder null; eine sehr alte Reservierung deutet auf einen Klärungsfall hin, den die Administration auflöst. GET /key zeigt den verwendeten Schlüssel und seine Grenzen. Die Verbrauchsübersicht zeigt deine FlowModels-Ausgaben. Belege findest du unter Rechnungen.
Verbrauch auswerten
GET /usage fasst den Verbrauch eines Zeitraums zusammen. start und end sind Tagesangaben im Format YYYY-MM-DD; ohne Angabe werden die letzten 30 Tage ausgewertet. group_by akzeptiert day (Standard), model, api_key und end_user. requests zählt Anfragen, nicht Anbieteraufrufe: eine Anfrage mit Zusammenfassung und Retrieval bleibt eine Anfrage. cost_micro_eur ist der bereits abgerechnete Endkundenbetrag in Micro-EUR.
GET /usage/requests listet die einzelnen Anfragen, neueste zuerst, seitenweise über limit und after und filterbar nach status, api_key, end_user und model. Die Liste enthält Zeitpunkt, Modell, Anbieter, Status, Fehlercode, Laufzeit, Tokenzahlen und Kosten. Anfrage- und Antworttext sind niemals Teil dieser Auskunft; dafür ist der Support zuständig. Beide Endpunkte sind mit einem Schlüssel für „Schlüssel verwalten“ abrufbar.
provider nennt den Anbieter, bei dem die Anfrage tatsächlich abgerechnet wurde, in derselben Schreibweise wie die erste Hälfte der Modellkennung. Schlüssel eines FlowSuite-Abonnements erreichen die beiden Verbrauchsendpunkte nicht; sie erhalten 403 insufficient_key_scope.
GET
/v1/credits
Guthaben abrufen
Liefert das unabhängige EUR-Konto des authentifizierten Teams, ohne Zahlung oder Modellaufruf.
Ersetzt den Tokenwert eines Schlüssels im authentifizierten Workspace. Die konfigurierte Übergangsfrist bestimmt, wie lange der vorherige Wert noch gilt.
Für FlowModels-Schlüssel gelten standardmäßig höchstens 4 MiB je JSON-Anfrage, 1.000 Nachrichten, 1.000.000 Zeichen pro Nachricht und 128 Werkzeuge in tools. Die Anfragen je Minute und die gleichzeitig laufenden Anfragen richten sich nach der Rate-Limit-Stufe des Workspace: 60 je Minute und 10 gleichzeitig in Stufe 1, 600 und 25 in Stufe 2 (ab 5 € bezahlt), 2.000 und 50 in Stufe 3 (ab 100 €) sowie 6.000 und 100 in Stufe 4 (ab 500 €). Der Aufstieg erfolgt automatisch; bei Abrechnung auf Rechnung zählt der abgerechnete Verbrauch. Weitere Token-, Kosten- und Monatsgrenzen können unabhängig davon greifen. GET /key nennt deine Stufe, das wirksame Limit je Minute und die Grenze gleichzeitiger Anfragen; ein Schlüssel kann sein Limit je Minute nur senken. Die Stufe steigt automatisch und sinkt nicht von selbst.
Häufige Antworten
400 invalid_field_value: Pflichtfeld, Wert oder Datentyp prüfen.
400 unsupported_field: Ein Feld wird für den gewählten Endpunkt nicht unterstützt. Prüfe dessen Parameterliste. Dieselbe Antwort erhältst du für context_compression, solange die Verlaufsverdichtung abgeschaltet ist.
400 context_length_exceeded: Der gesendete Verlauf passt nicht in das Eingabefenster des Modells. Die Meldung nennt max_input_tokens und estimated_input_tokens; param ist messages. Sende weniger Nachrichten oder setze context_compression: true.
401 invalid_api_key: Token fehlt, ist ungültig, abgelaufen oder gesperrt.
403 insufficient_key_scope: Einen Schlüssel mit „KI nutzen“ verwenden.
403 account_suspended: Der FlowModels-Zugang dieses Kontos ist gesperrt. Wende dich an den Support; ein erneuter Versuch hilft nicht.
404 model_not_found: Vollständige Kennung mit der aktuellen Modellliste abgleichen.
404 conversation_not_found: Workspace, Endnutzerkennung und Unterhaltungs-UUID prüfen.
409 idempotency_key_in_progress: Die Anfrage mit diesem Idempotenzschlüssel läuft noch oder ihr Ergebnis ist nach einem Ausfall nicht sicher bekannt.
413 payload_too_large: JSON-Anfrage verkleinern.
422 idempotency_key_reuse: Derselbe Idempotenzschlüssel wurde für andere Anfragedaten benutzt.
429 rate_limit_exceeded: Die übermittelte Wartezeit beachten.
429 concurrent_requests_exceeded: Es laufen bereits so viele Anfragen gleichzeitig, wie die Stufe des Workspace erlaubt. Weniger Anfragen parallel senden und nach der Wartezeit aus Retry-After wiederholen.
429 spend_limit_exceeded: Das monatliche Schlüssellimit oder ein freigegebener Kreditrahmen reicht nicht aus; eine Aufladung ändert kein Schlüssellimit.
503 routing_unavailable: FlowModels ist vorübergehend abgeschaltet. Die Wartezeit aus dem Header Retry-After beachten; es wird weder Guthaben reserviert noch ein Anbieter aufgerufen.
503 provider_overloaded: Der Anbieter hat gerade keine Kapazität. Die Wartezeit aus dem Header Retry-After beachten und den Aufruf danach wiederholen.
400 invalid_cursor: Der Cursor fehlt, ist leer oder gehört nicht zur aufgerufenen Liste.
400 unsupported_for_model: Das Feld ist gültig, das gewählte Modell nimmt es aber nicht an; param nennt das Feld. Welche Felder ein Modell annimmt, steht in GET /models.
401 invalid_token_source: Der Schlüssel wurde nicht über Authorization: Bearer übergeben.
404 response_not_found: Die Antwort ist unbekannt, abgelaufen oder nicht gespeichert.
404 file_not_found: Die Datei ist unbekannt oder gehört nicht zu diesem Workspace.
404 memory_not_found: Die Erinnerung oder der zugehörige Endnutzer wurde nicht gefunden.
404 end_user_not_found: Der Endnutzer ist unbekannt oder gehört nicht zu diesem Workspace.
404 webhook_endpoint_not_found: Das Webhook-Ziel ist unbekannt oder gehört nicht zu diesem Workspace.
409 memory_revision_conflict: Die Erinnerung wurde zwischenzeitlich geändert.
410 model_deprecated: Das Modell ist abgekündigt und nicht mehr aufrufbar; wähle ein Modell aus GET /models.
413 file_too_large: Die Datei überschreitet die Uploadgrenze.
429 credit_balance_exhausted: Das Guthaben reicht für diese Anfrage nicht aus; eine Aufladung ist erforderlich.
429 period_spend_limit_exceeded: Die Ausgabengrenze des Kalendermonats wäre überschritten; eine Aufladung allein ändert diese Grenze nicht.
502 routing_execution_failed: Die Anfrage konnte nicht abgeschlossen werden, zum Beispiel weil der gewählte Anbieter nicht geantwortet hat. FlowModels weicht nicht auf ein anderes Modell aus; du entscheidest, ob du die Anfrage wiederholst.
503 pricing_unavailable: Für das Modell ist momentan kein belastbarer Preis verfügbar.
Sicher wiederholen und Fehler zuordnen
Verwende für wiederholte POST-Anfragen einen stabilen Idempotency-Key pro logischem Vorgang. Eine identische, erfolgreich abgeschlossene JSON-Anfrage kann innerhalb des Aufbewahrungsfensters von standardmäßig 24 Stunden erneut beantwortet werden. Geänderte Inhalte oder Dateinamen benötigen einen neuen Schlüssel. Bei einem Verbindungsabbruch kann trotzdem bereits kostenpflichtige Verarbeitung stattgefunden haben; wechsle deshalb nicht automatisch auf einen neuen Schlüssel.
Fehler enthalten error.message, error.type, error.code und gegebenenfalls error.param. Bewahre die flowai_request_id aus der Antwort für Supportanfragen auf.
Aufbewahrung deiner Aufrufprotokolle
Zu jedem Aufruf speichern wir ein Protokoll mit Zeitpunkt, Modell, Tokenzahlen, Laufzeit, Status und flowai_request_id. Der übermittelte Anfrageinhalt und der Antworttext werden zusätzlich für die Supportdiagnose vorgehalten und nach 30 Tagen automatisch gelöscht; das Protokoll selbst bleibt als Nachweis für Verbrauch und Abrechnung 400 Tage erhalten. Auf Wunsch deaktivieren wir die Speicherung von Anfrage- und Antworttext für deinen Workspace vollständig, dann enthalten die Protokolle nur noch die genannten technischen Angaben. Ohne diese Inhalte kann der Support einen gemeldeten Aufruf allerdings nicht mehr nachvollziehen.
Stabile Feldnamen
Warum einige Felder weiterhin „flowai“ heißen
FlowModels trug früher einen anderen Produktnamen. Der Name hat sich geändert, die Antworten deiner Integration nicht. Feldnamen, Fehlercodes und Protokollnamen sind ein Vertrag mit deinem Code: Würden sie mit umbenannt, müsste jede bestehende Integration gleichzeitig angepasst werden. Sie bleiben deshalb dauerhaft gleich und tragen weiter das Wort flowai.
flowai_request_id: Kennung einer Anfrage in jeder Antwort, zum Beispiel für Supportanfragen.
usage.flowai.*: Zusatzangaben zum Verbrauch, etwa usage.flowai.compression.
flowai_limits und flowai_tools: Feldnamen in Modelleinträgen und Anfragen.
error.code und error.type: maschinenlesbare Fehlerangaben. Der Meldungstext in error.message kann sich ändern, Code und Typ nicht.
flowai-ticket.*: WebSocket-Unterprotokoll der Live-Transkription.
Du kannst dich darauf verlassen: Diese Namen ändern sich nicht mit dem Produktnamen.
Cookies und Statistik
Wir verwenden notwendige Cookies, damit FlowModels funktioniert. Mit deiner Einwilligung messen wir zusätzlich mit Google Analytics über den Google Tag Manager, wie die Seiten genutzt werden. Dabei können Daten an Google in den USA übermittelt werden. Du kannst deine Auswahl jederzeit über „Cookie-Einstellungen“ im Fußbereich ändern oder widerrufen.
Datenschutzerklärung
Deine Auswahl konnte nicht gespeichert werden. Bitte lade die Seite neu und versuche es noch einmal.
Anbieter und Cookies anzeigen
Notwendig
Sitzung und Formularschutz
Creative Skyline (diese Website)
Hält deine Sitzung offen, zum Beispiel für Anmeldung, Warenkorb und Formulare, und schützt Formulare vor gefälschten Anfragen (CSRF).
Rechtsgrundlage: § 25 Abs. 2 Nr. 2 TDDDG; Art. 6 Abs. 1 lit. f DSGVO, bei angemeldeten Kunden Art. 6 Abs. 1 lit. b DSGVO
creative_skyline_session: 1 Tag
XSRF-TOKEN: 1 Tag
Cookie-Auswahl
Creative Skyline (diese Website)
Speichert deine Auswahl in diesem Banner und deine Einwilligungs-ID, damit wir die Auswahl nicht bei jedem Besuch erneut abfragen und eine Einwilligung nachweisen können.
Rechtsgrundlage: § 25 Abs. 2 Nr. 2 TDDDG; Art. 6 Abs. 1 lit. c DSGVO in Verbindung mit Art. 7 Abs. 1 DSGVO
fm_cookie_consent: 1 Jahr
Angemeldet bleiben
Creative Skyline (diese Website)
Hält dich angemeldet, wenn du beim Login „Angemeldet bleiben“ wählst. Wird nur dann gesetzt.
Rechtsgrundlage: § 25 Abs. 2 Nr. 2 TDDDG; Art. 6 Abs. 1 lit. b DSGVO
remember_web_*: 400 Tage
Vertrautes Gerät
Creative Skyline (diese Website)
Merkt sich für 30 Tage, dass du dieses Gerät bei der Zwei-Faktor-Anmeldung als vertrauenswürdig markiert hast. Wird nur dann gesetzt, gilt nur für diesen Host und ist verschlüsselt.
Rechtsgrundlage: § 25 Abs. 2 Nr. 2 TDDDG; Art. 6 Abs. 1 lit. b DSGVO
fc_td: 30 Tage
Cloudflare Turnstile
Cloudflare, Inc., USA
Prüft bei Formularen wie Login, Registrierung und Kontakt, ob ein Mensch sie absendet, und schützt so vor Spam und automatisierten Angriffen.
Rechtsgrundlage: § 25 Abs. 2 Nr. 2 TDDDG; Art. 6 Abs. 1 lit. f DSGVO
Nur auf Seiten mit einem geschützten Formular. Das Skript wird von challenges.cloudflare.com geladen; Cloudflare verarbeitet dabei deine IP-Adresse und technische Merkmale des Browsers. Grundlage für die Übermittlung in die USA ist das EU-US Data Privacy Framework.
Keine Cookies auf dieser Website
Stripe
Stripe Payments Europe, Limited, Irland
Wickelt Kartenzahlungen und Lastschriften ab und erkennt Betrugsversuche.
Rechtsgrundlage: § 25 Abs. 2 Nr. 2 TDDDG; Art. 6 Abs. 1 lit. b DSGVO
Nur auf Seiten, auf denen du eine Zahlung oder Zahlungsart einrichtest. Eine Verarbeitung durch die Stripe, Inc. in den USA ist möglich; Grundlage ist das EU-US Data Privacy Framework.
__stripe_mid: 1 Jahr
__stripe_sid: 30 Minuten
Statistik
Google Tag Manager und Google Analytics
Google Ireland Limited, Gordon House, Barrow Street, Dublin 4, Irland
Reichweitenmessung: Über den Google Tag Manager laden wir Google Analytics 4, das misst, welche Seiten wie oft und wie lange aufgerufen werden, woher Besucher kommen und welche Geräte sie nutzen. Der Tag Manager selbst setzt keine Cookies.
Wird erst nach deiner Einwilligung geladen (Google Consent Mode, alles ist vorher abgelehnt, Werbe-Speicherung bleibt abgelehnt). Daten können an Google LLC in den USA übermittelt werden; Grundlage ist das EU-US Data Privacy Framework. Beim Widerruf löschen wir die Analytics-Cookies.