BazaarLink-Dokumentation

Preise

BazaarLink bepreist die Modellnutzung ohne Aufschlag (identisch mit dem offiziellen Listenpreis jedes Anbieters). Bei der Aufladung (Einzahlung) werden Plattformgebühren erhoben: eine Transaktionsgebühr von 10 % plus 5 % Taiwan VAT auf TWD-Kanälen. Abrechnung in USD mit TWD-Angeboten und elektronischen Einheitsrechnungen. Selbstbedienungs-Aufladungen mit nutzungsabhängiger Bezahlung; Unternehmen können eine monatliche Abrechnung vereinbaren (Netto-30, verhandelbar).

So funktioniert es

• Verbrauch (Lastschrift): Jeder API-Anruf wird nach tatsächlicher Token-Nutzung zum offiziellen USD-Listenpreis des Anbieters abgerechnet und von Ihrem Guthaben abgezogen – kein Aufschlag, keine zusätzliche Gebühr für den Verbrauch.
• Aufladung (Einzahlung): TWD wird zum Echtzeit-Verkaufskurs in USD umgewandelt und Ihrem Guthaben hinzugefügt; Bei der Aufladung wird eine Transaktionsgebühr von 10 % erhoben.
• • Zahlungsarten und kanalspezifische Gebühren werden im aktuellen Checkout angezeigt.
• • Bei geeigneten TWD-Kanälen werden anwendbare Steuer- und E-Rechnungsbedingungen vor der Zahlung angezeigt.
• • Banküberweisung: Für größere oder geschäftliche Aufladungen kontaktieren Sie uns, um eine Überweisung und individuelle Rechnungsstellung zu vereinbaren.
• Rechnungen sind nur über einen aktuell angebotenen rechnungsfähigen Kanal oder bestätigte Unternehmenskonditionen verfügbar. Für Steuernummer, Angebot oder Monatsabrechnung bitte vor der Zahlung den Vertrieb kontaktieren.

Zum Wechselkurs

Die Devisenumrechnung verwendet den Echtzeitkurs. Bei der monatlichen Abrechnung wird der Tarif zum Zeitpunkt der Abrechnung (Abrechnung) verwendet, während Prepaid-Aufladungen zum Tarif zum Zeitpunkt der Aufladung umgerechnet werden. Der Tarif und der Zeitstempel werden zusammen mit den Rechnungsunterlagen gespeichert.

Abrechnungsschutz bei fehlgeschlagenen Anfragen

Wenn eine Upstream-Anfrage ohne abrechenbare Nutzungsdaten fehlschlägt, gibt BazaarLink den gesamten reservierten Betrag automatisch zurück. Auch wenn der Stream bereits begonnen hatte, beträgt die Belastung für diesen Versuch 0 USD.

0 Ausgabe-Tokens bedeutet nicht immer kostenlos

usage.cost ist der für die Anfrage berechnete USD-Betrag. Auch bei 0 Ausgabetokens können Eingabetokens berechnet werden. Prüfen Sie usage.cost oder den Activity-Eintrag für den Endbetrag.

Schnellstart

Drei Wege zur Integration

Starten Sie in unter 5 Minuten. BazaarLink ist vollständig kompatibel mit dem OpenAI SDK — ändern Sie einfach die

Für lange Anfragen von mehr als 100 Sekunden wird stream:true empfohlen. Bei nicht gestreamten Anfragen wird nach etwa 12 Sekunden (Standardwert, über die Deployment-Einstellungen anpassbar) zunächst 200 zurückgegeben und mit dem Senden von Keepalive-Leerzeichen begonnen. Tritt danach ein Fehler auf, wird er als 200 + error-JSON zurückgegeben. Keepalive besteht aus Leerzeichen vor dem JSON-Body, die Standard-JSON-Parser ignorieren.

Base-URL

https://api.bazaarlink.ai/v1

api.bazaarlink.ai ist ein reiner API-Einstiegspunkt, der getrennt von der Website bereitgestellt wird. Die bisherige Basis-URL https://bazaarlink.ai/api/v1 wird weiterhin vollständig unterstützt — bestehende Integrationen müssen nicht geändert werden.

OpenAI SDK verwenden

BazaarLink ist vollständig kompatibel mit dem OpenAI SDK. Ändern Sie einfach die Base-URL und den API-Schlüssel — der gesamte andere Code bleibt gleich.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.bazaarlink.ai/v1",
    api_key="sk-bl-YOUR_API_KEY",
)

completion = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {"role": "user", "content": "What is the meaning of life?"}
    ],
)

print(completion.choices[0].message.content)

Eigene Upstream-Schlüssel (BYOK)

Verbinden Sie einen Upstream-API-Schlüssel mit Ihrem Konto oder Ihrer Organisation. Geeignete Anfragen verwenden zuerst Ihren Schlüssel. Nach einem Upstream-Fehler kann eine andere verfügbare Quelle versucht werden; ist keine verfügbar, wird ein Fehler zurückgegeben. Persönliche Schlüssel verwalten Sie auf der Schlüsselseite, Organisationsschlüssel in den Organisationseinstellungen. Zu den BYOK-Einstellungen →

Inhaltsfilterung

Beidseitiger Inhaltsschutz für Ihren API-Traffic: Anfragen mit Prompt-Injection-Versuchen werden blockiert (400), sensible Daten in Anfragen und Antworten (API-Schlüssel, Kartennummern, Ausweisnummern u. a.) werden automatisch geschwärzt. Regeln und Ausnahmeliste sind anpassbar, Nutzungsstatistiken inklusive. Zu den Inhaltsfilter-Einstellungen →

Websuche (:online)

Durchsucht das Web, bevor das Modell antwortet, und stellt die Suchergebnisse als Referenz bereit. Geeignet für Fragen mit aktuellem Informationsbedarf, etwa zu Nachrichten, Preisen, kürzlich veröffentlichten Richtlinien oder Produkten.

Unterstützte Endpunkte

• POST /api/v1/chat/completions
• POST /api/v1/messages
• POST /api/v1/responses

Streaming (stream: true) und Nicht-Streaming werden unterstützt.

Verwendung

Methode 1: :online an den Modellnamen anhängen

curl https://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini:online",
    "messages": [{ "role": "user", "content": "Welche KI-Nachrichten gibt es heute in Taiwan?" }]
  }'

Methode 2: den Parameter plugins verwenden

{
  "model": "gpt-5.4-mini",
  "messages": [{ "role": "user", "content": "..." }],
  "plugins": [{
    "id": "web",
    "max_results": 5,
    "query_source": "last_user",
    "country": "taiwan",
    "time_range": "week"
  }]
}

Methode 3: web_search_options verwenden

{
  "model": "gpt-5.4-mini",
  "messages": [{ "role": "user", "content": "..." }],
  "web_search_options": { "search_context_size": "high", "query_source": "conversation" }
}

Sie können eine beliebige Methode verwenden oder sie kombinieren.

Suchparameter

Die folgenden Parameter können im web-Element von plugins oder in web_search_options stehen. Wenn beide unterschiedliche Werte angeben, hat plugins Vorrang.

Priorität der Suchtiefe: engine (die vier Werte oben) > mode > search_context_size > Standard medium.

Das Parameterformat von plugins und web_search_options ist mit OpenRouter kompatibel; vorhandene Anfragen können direkt verwendet werden.

Auch kompatible Such-Tool-Syntax für Vercel AI Gateway

tools von Chat Completions akzeptiert ebenfalls das folgende Such-Tool-Format. Es gilt als eine Websuche, wird von der Websuche dieser Plattform verarbeitet und verwendet dieselbe Abrechnung und dasselbe Zitatformat:

{
  "model": "gpt-5.4-mini",
  "messages": [{ "role": "user", "content": "..." }],
  "tools": [{
    "type": "vercel:perplexity_search",
    "config": { "query": "Taiwans Halbleiterexporte 2026", "max_results": 5 }
  }]
}

• Zulässige type: vercel:perplexity_search, vercel:exa_search, vercel:parallel_search, vercel:tako_search. Diese type-Werte verhalten sich gleich und kosten gleich viel.
• config.query entspricht search_prompt; config.max_results (oder num_results) und config.country entsprechen den gleichnamigen Parametern oben. Nicht erkannte Felder werden ignoriert.
• Diese Such-Tools werden nicht an das Modell weitergegeben.
• Enthält eine Anfrage mehrere Such-Tools, wird nur das erste verwendet.

Das Tool `web_search_preview` wird ebenfalls akzeptiert

Wird in tools von Responses oder anderen Endpunkten { "type": "web_search_preview" } angegeben, gilt dies ebenfalls als eine Websuche und wird von der Websuche dieser Plattform mit derselben Abrechnung und demselben Zitatformat verarbeitet. Dieses Tool wird nicht an das Modell weitergegeben.

Bei gleichzeitiger Verwendung mehrerer Schreibweisen

:online, plugins, web_search_options und Such-Tools (einschließlich web_search_preview) können zusammen erscheinen, aber jede Anfrage führt nur eine Suche aus und wird einmal berechnet; bei search_queries gilt die Anzahl der Anfragen. Die Priorität der Suchanfrage lautet: search_queries > config.query des Such-Tools > search_prompt > query_source. Andere Parameter werden gemäß den Prioritäten oben zusammengeführt.

400 invalid_web_search_options wird nur bei Parameter-Typfehlern (etwa einer Zahl für engine oder einem nicht aus Strings bestehenden Array für include_domains) oder Werten außerhalb des Bereichs zurückgegeben.

Suchstufen

Ohne Angabe einer Stufe wird medium verwendet.

Zitate in der Antwort

Gefundene Quellen werden über annotations im branchenüblichen Format url_citation zurückgegeben:

"annotations": [
  {
    "type": "url_citation",
    "url_citation": {
      "url": "https://example.com/article",
      "title": "Artikeltitel",
      "content": "Zusammenfassung der Quelle…",
      "start_index": 0,
      "end_index": 0
    }
  }
]

• Jede Referenzquelle erhält einen Zitateintrag.
• Wenn das Modell die entsprechende Quelle in seiner Antwort markiert (z. B. [source-1]), geben start_index und end_index die Position der Markierung im Antworttext an; ohne Markierung sind beide 0.

Positionen nach Endpunkt:

• Chat Completions: Nicht-Streaming verwendet choices[].message.annotations; Streaming sendet vor [DONE] einen zusätzlichen Block, der nur delta.annotations enthält.
• Responses: In annotations innerhalb von output_text; Streaming sendet sie mit Abschlussereignissen wie response.output_text.done.
• Messages: Im Textinhaltsblock an annotations angehängt; Streaming sendet sie im text_delta-Ereignis vor dem Ende.

Abrechnung

• Kosten pro Anfrage = Modellkosten + Websuchkosten.
• Websuche wird pro Suche berechnet; der Einzelpreis folgt der Plattformpreisliste. Erweiterte Tiefe (high oder über engine/mode ausgewählt) hat einen höheren Einzelpreis.
• Auch kostenlose Modelle verursachen Websuchkosten; das Modell selbst bleibt kostenlos.
• Jede Anfrage sucht standardmäßig einmal. Bei search_queries entspricht die Anzahl der Suchen der Anzahl der Anfragen, und die Kosten werden entsprechend berechnet. Ein erneuter Versuch nach einem serverseitigen Routenwechsel wiederholt weder Suche noch Berechnung.
• In den folgenden Fällen entstehen keine Websuchkosten:
  • Die Suche selbst schlägt fehl (503, siehe unten).
  • Einzelne Fehler bei search_queries (nur erfolgreiche Einträge werden berechnet).
  • Die Suche ist erfolgreich, aber das Modell erzeugt letztlich keine Antwort.
• Bei der Reservierung des Guthabens werden die Suchkosten einbezogen. Der tatsächliche Abzug erscheint in usage.cost der Antwort und im Abrechnungsdatensatz.

Fehler und Limits

• Ratenlimits, Modellberechtigungen, Inhaltsprüfung und andere Prüfungen normaler Anfragen werden vor der Suche abgeschlossen; blockierte Anfragen führen keine Suche aus.
• Suchparameter und Tools (:online-Suffix, das web-Element in plugins, web_search_options, die Such-Tools oben und web_search_preview) werden ausschließlich von dieser Plattform verarbeitet und nicht an das Modell weitergegeben.

Social-Daten (:social)

Hängen Sie :social an einen Modellnamen, wenn Ihre Frage eine Social-Plattform betrifft. Bevor das Modell antwortet, ruft BazaarLink passende Beiträge, Profile oder Kommentare dieser Plattform ab und stellt sie als Referenzmaterial bereit. Lassen sich die Plattformdaten nicht rechtzeitig abrufen, fällt die Anfrage auf die normale Websuche zurück, sodass Sie trotzdem eine Antwort erhalten.

Beispiel

curl https://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  --max-time 60 \
  -d '{
    "model": "gpt-5.4-mini:social",
    "messages": [{ "role": "user", "content": "Aktuelle Beiträge auf X zu GPT-6" }]
  }'

Wichtig zu wissen

• Wartezeit: Social-Daten werden live abgerufen, daher kann eine :social-Anfrage 20 bis 40 Sekunden dauern, bis die Antwort beginnt. Nach 40 Sekunden erfolgt der Fallback auf die Websuche. Setzen Sie das Client-Timeout auf mindestens 60 Sekunden. :online bleibt schnell, da es die normale Websuche ist.
• Preis: Anfragen, die mit Social-Daten beantwortet werden, nutzen dasselbe tägliche kostenlose Suchkontingent wie :online (5 pro Tag ohne Guthaben, 10 mit Guthaben oder Abonnement, Zurücksetzung um 00:00 UTC). Über das Kontingent hinaus wird jede Anfrage nach der Preistabelle der Data API abgerechnet (siehe GET /v1/data/catalog), zusätzlich zu den Token-Kosten des Modells. Eine Anfrage, die auf die Websuche zurückfällt, wird wie :online abgerechnet.
• Abdeckung: :social liest nur einen Teil der sozialen Plattformen, die Liste hängt von den aktivierten Einstellungen ab; die aktuelle Liste steht unter /solutions/data-api#social-suffix. Eine Plattform, die im Data-API-Katalog steht, aber nicht in dieser Liste, wird von :social nicht gelesen; eine Anfrage dazu oder ohne Plattformbezug wird über die Websuche beantwortet.
• Kompatibilität: funktioniert mit POST /api/v1/chat/completions, /api/v1/messages und /api/v1/responses, mit und ohne Streaming, mit denselben Quellenangaben wie :online. :online und :social lassen sich nicht in einem Modellnamen kombinieren (400 invalid_web_search_options).

Von OpenRouter migrieren

Die BazaarLink-API ist OpenRouter-kompatibel — die meisten Integrationen wechseln durch Ändern von zwei Werten: die Base-URL zu https://api.bazaarlink.ai/v1 und den API-Schlüssel zu einem BazaarLink-Schlüssel, der mit sk-bl- beginnt.

1. Base-URL: https://openrouter.ai/api/v1 → https://api.bazaarlink.ai/v1
2. API-Schlüssel: sk-or-... → sk-bl-... (erstellen Sie einen unter /keys)
3. Modell-IDs: gleiches provider/model-Format (z.B. anthropic/claude-sonnet-4.6); vollständiger Katalog unter GET /v1/models
4. models[]-Fallbacks, Streaming, Tool Calling und Structured Outputs verwenden dieselbe Request-Form

  from openai import OpenAI

  client = OpenAI(
-     base_url="https://openrouter.ai/api/v1",
-     api_key="sk-or-...",
+     base_url="https://api.bazaarlink.ai/v1",
+     api_key="sk-bl-...",
  )

Authentifizierung

Alle API-Anfragen erfordern einen Authorization-Header mit Ihrem API-Schlüssel.

Authorization: Bearer sk-bl-YOUR_API_KEY

Holen Sie sich Ihren API-Schlüssel vom Dashboard. Bewahren Sie Ihren Schlüssel sicher auf — exponieren Sie ihn nicht in clientseitigem Code.

Optionale Header

Prinzipien

BazaarLink basiert auf drei Kernprinzipien:

1. Einheitliche Schnittstelle

Eine API, ein SDK, Hunderte von Modellen. Wechseln Sie zwischen OpenAI, Anthropic, Google Gemini, Meta Llama und anderen, ohne Ihren Code zu ändern — ändern Sie einfach die Modell-ID.

2. Preisoptimierung

BazaarLink leitet automatisch zum kostengünstigsten Anbieter für Ihr gewähltes Modell weiter. Sie zahlen nur, was Sie nutzen, abgerechnet in USD mit voller Rechnungsunterstützung.

3. Anfrageverarbeitung

Bei einem Problem mit einer Upstream-Quelle kann die Anfrage eine andere verfügbare Quelle versuchen. Ist keine verfügbar, wird ein Fehler zurückgegeben.

Multimodal

BazaarLink unterstützt multimodale Eingaben — senden Sie Bilder, Audio und Dateien zusammen mit Text an Modelle, die sie unterstützen. Inhalte werden an den Upstream-Anbieter weitergeleitet.

Unterstützte Modalitäten

Beispiele:

# Image — URL or base64 data URI
curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-3.5-flash","messages":[{"role":"user","content":[
        {"type":"text","text":"What is in this?"},
        {"type":"image_url","image_url":{"url":"https://example.com/photo.jpg"}}
      ]}]}'

# File / PDF — base64 data URI only, no URL
curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-3.5-flash","messages":[{"role":"user","content":[
        {"type":"file","file":{"filename":"doc.pdf","file_data":"data:application/pdf;base64,JVBER..."}},
        {"type":"text","text":"Summarize this."}
      ]}]}'

# Audio — raw base64, no URL. "format" is required
curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-3.5-flash","messages":[{"role":"user","content":[
        {"type":"text","text":"Transcribe this."},
        {"type":"input_audio","input_audio":{"data":"UklGRi...","format":"wav"}}
      ]}]}'

# Video — URL (CDN) or base64 data URI
curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"google/gemini-3.5-flash","messages":[{"role":"user","content":[
        {"type":"text","text":"Describe this video."},
        {"type":"video_url","video_url":{"url":"https://example.com/clip.mp4"}}
      ]}]}'

Bilder senden

Verwenden Sie das Content-Array-Format mit image_url-Teilen. Unterstützte Formate: PNG, JPEG, WebP und GIF (einschließlich animiert). Sie können mehrere Bilder in einer einzigen Nachricht einschließen — jedes als separater image_url-Teil:

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer sk-bl-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role":"user","content":[
      {"type":"text","text":"What is in this image?"},
      {"type":"image_url","image_url":{"url":"https://example.com/photo.jpg","detail":"auto"}}
    ]}]
  }'

Limits

BazaarLink erzwingt zwei unabhängige Limits: ein Rate Limit für Anfragen pro Minute und ein Guthaben-Limit für Kontoausgaben. Bei Überschreitung des Rate Limits erhalten Sie HTTP 429; ist das Guthaben aufgebraucht, erhalten Sie HTTP 402.

Rate-Grenzwerte

Rate Limits gelten pro Benutzer (nicht pro Schlüssel), gemessen in Anfragen pro Minute (RPM). Es gibt kein Tageslimit. Die Stufe wird automatisch durch Ihr Kontoguthaben bestimmt.

Bei Überschreitung eines Rate Limits erhalten Sie eine 429-Antwort mit einem Retry-After-Header. Implementieren Sie exponentielles Backoff beim erneuten Versuch.

Antwort-Header

Antworten können x-request-id, bei nicht gestreamten Antworten x-generation-id, x-ratelimit-*, bei Bedarf retry-after und beim Routing mit auto oder auto:free x-auto-resolved-model enthalten.

x-request-id: 85e6f35c71a31f19-SJC
x-generation-id: 85e6f35c71a31f19-SJC
x-ratelimit-limit: 200
x-ratelimit-remaining: 198
x-ratelimit-reset: 1740000060
retry-after: 5
x-auto-resolved-model: openai/gpt-4o

Guthaben-Limits

Eine 402-Antwort bedeutet, dass Ihr Kontoguthaben oder das Ausgabenlimit eines Schlüssels null erreicht hat — nicht, dass Sie zu schnell Anfragen senden. Diese Antworten enthalten keine Rate-Limit-Header, und wenn das Limit während des Streamings erreicht wird, erhalten Sie ein SSE-Fehlerereignis statt einer HTTP-Statusänderung.

IP-Allowlist

Für jeden API-Schlüssel kann eine eigene IP-Allowlist festgelegt werden, sodass nur Anfragen von den angegebenen Quell-IP-Adressen diesen Schlüssel verwenden können.

Wann sie sinnvoll ist

Sie eignet sich für Produktionsdienste auf Servern mit fester ausgehender IP-Adresse. Wenn Ihre Anwendung über ein Heimnetz, ein Mobilfunknetz oder eine andere wechselnde Adresse zugreift, prüfen Sie zuerst, ob die ausgehende IP stabil ist — andernfalls können Sie sich selbst aussperren.

Einrichtung

Öffnen Sie /keys und öffnen Sie im Menü „…“ des gewünschten Schlüssels „IP-Allowlist“. Geben Sie die Einträge ein und speichern Sie.

Alternativ können Sie PATCH /api/v1/keys/:id mit einer angemeldeten Sitzung oder einem Management-API-Schlüssel verwenden:

PATCH https://api.bazaarlink.ai/v1/keys/KEY_ID
Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY
Content-Type: application/json

{
  "allowedCidrs": [
    "203.0.113.7",
    "198.51.100.0/24"
  ]
}

# Clear the allowlist and return to unrestricted access
{"allowedCidrs": []}

Format der Einträge

Geben Sie in der UI einen Wert pro Zeile ein. In der API kommen dieselben Werte in das Array `allowedCidrs`. Akzeptiert werden eine nackte IPv4-Adresse, ein IPv4-CIDR oder ein IPv6-Literal (nur exakter Abgleich).

203.0.113.7
198.51.100.0/24
2001:db8::1

Verhalten

Leer lassen (ein leeres []-Array senden) erlaubt alle Quell-IP-Adressen. Das ist der Standard; vorhandene Schlüssel behalten ihr bisheriges Verhalten.

Die Quell-IP wird aus dem Header `cf-connecting-ip` gelesen.

Ist die Liste nicht leer, kann die Quell-IP aber nicht ermittelt werden, wird die Anfrage abgelehnt (fail-closed).

Persönlicher Schutzschalter

Ein festes 1-Minuten- und 1-Stunden-USD-Ausgabenlimit für alle Ihre API-Schlüssel. Neue Anfragen erhalten HTTP 429, sobald ein Fensterschwellenwert erreicht wird; das Fenster wird automatisch an der Zeitgrenze zurückgesetzt.

Kontosicherheit

Neben Ihrem Passwort unterstützt BazaarLink auch die Zwei-Faktor-Authentifizierung für zusätzlichen Schutz bei der Anmeldung.

Zwei-Faktor-Authentifizierung (TOTP) aktivieren

1. Öffnen Sie die Seite „Einstellungen“, suchen Sie den Bereich „Zwei-Faktor-Authentifizierung (TOTP)“ und klicken Sie auf „Zwei-Faktor-Authentifizierung aktivieren“.
2. Scannen Sie den QR-Code mit einer Authenticator-App (z. B. Google Authenticator) oder geben Sie das unten angezeigte Secret manuell ein.
3. Geben Sie den von der Authenticator-App generierten 6-stelligen Code ein und bestätigen Sie, um die Aktivierung abzuschließen.

Nach der Aktivierung werden 8 Backup-Codes angezeigt (nur einmal sichtbar) — jeder ist 10 Zeichen lang und nur einmal gültig. Notieren oder kopieren Sie sie sofort an einem sicheren Ort außerhalb Ihres Telefons; nutzen Sie einen Backup-Code zur Anmeldung, wenn Sie Ihr Telefon verlieren oder keinen Zugriff auf Ihre Authenticator-App haben.

Weitere Möglichkeiten, Ihr Konto zu schützen

Kombinieren Sie diese Funktionen mit der Zwei-Faktor-Authentifizierung, um den Schaden durch einen kompromittierten oder missbrauchten Schlüssel weiter zu begrenzen:

• IP-Allowlist — beschränkt einen API-Schlüssel auf bestimmte Quell-IPs.
• Persönlicher Schutzschalter — legt Ausgabenlimits pro Minute und pro Stunde fest, die bei Überschreitung automatisch pausieren.
• Ausgabenlimit pro Schlüssel — legt beim Erstellen oder Aktualisieren eines API-Schlüssels ein tägliches, wöchentliches oder monatliches Ausgabenlimit fest.

Bilderzeugung

Bilder über /v1/chat/completions mit modalities:["image"] oder das OpenAI DALL·E-kompatible /v1/images/generations generieren.

curl -N https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"openai/gpt-5.4-image-2","messages":[{"role":"user","content":"a red cat on a sofa"}],"modalities":["image","text"],"stream":true}'

Vollständiger Ablauf (Streaming, Bildbearbeitung, SSE-Protokoll, Modellliste) → API-Referenz

Videogenerierung

Asynchroner 3-Schritt-Ablauf (submit → poll → content). Videogenerierung dauert 30 Sekunden bis 5 Minuten.

curl https://api.bazaarlink.ai/v1/videos \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"bytedance/seedance-2.0","prompt":"a bird flying over mountains","duration":3}'
# → 202 { "id": "vjob_xxx", "status": "pending" }

Vollständiger Ablauf (Polling, Download, Aufgabentypen, Hinweise) → API-Referenz

PDF-Eingaben

Senden Sie PDF-Dokumente direkt in Nachrichten an Modelle mit nativer PDF-Unterstützung (z. B. Claude, Gemini). BazaarLink leitet die Datei direkt an das Modell weiter — abgerechnet als normale Input-Tokens, ohne Zusatzkosten oder zusätzlichen Verarbeitungsschritt.

Unterstützte Formate

• PDF-Dokumente (Text, Bilder, Tabellen, gescannt)
• Base64-kodierte Daten-URL (`data:application/pdf;base64,...`)
• Mehrseitige Dokumente
• Nur passwortfreie PDFs

import base64

with open("document.pdf", "rb") as f:
    pdf_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="anthropic/claude-sonnet-4.6",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "file",
                "file": {
                    "filename": "document.pdf",
                    "file_data": f"data:application/pdf;base64,{pdf_data}",
                },
            },
            {"type": "text", "text": "Summarize this document."},
        ],
    }],
)

Video-Eingaben

Senden Sie Videodateien an Modelle mit Videoeingabe-Unterstützung zur Analyse, Beschriftung oder Beantwortung von Fragen zu Szenen und Ereignissen. Funktioniert mit einer direkten URL oder einem base64-Daten-URI — eine URL ist effizienter für öffentlich zugängliche Videos, base64 für lokale Dateien oder private Videos.

Unterstützte Formate

response = client.chat.completions.create(
    model="google/gemini-3.5-flash",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "video_url",
                "video_url": {"url": "https://example.com/video.mp4"},
            },
            {"type": "text", "text": "What is happening in this video?"},
        ],
    }],
)

Vollständige API-Referenz →

OAuth PKCE

OAuth 2.0 PKCE (Proof Key for Code Exchange) ermöglicht öffentlichen Client-Apps (Browser-SPAs, mobile Apps) API-Aufrufe im Namen einzelner Benutzer ohne clientseitige Speicherung eines langlebigen Server-Secrets.

Wann OAuth PKCE verwenden

• Browser-SPA oder mobile App mit benutzerbezogener Abrechnung
• Multi-Tenant SaaS — jeder Endbenutzer zahlt für seine eigene API-Nutzung
• Sie können kein Shared Secret clientseitig speichern (öffentlicher Client)
• Sie benötigen pro Benutzer einen eigenen, widerrufbaren Schlüssel (er läuft nicht von selbst ab) statt eines einzelnen gemeinsamen API-Schlüssels

Was Ihre Benutzer sehen

Beschreiben Sie diese Schritte auf Ihrem eigenen Anmeldebildschirm:

1. In Ihrer App wählen sie „Mit BazaarLink anmelden“ (oder wie auch immer Sie die Schaltfläche nennen).
2. Ihr Browser öffnet die BazaarLink-Autorisierungsseite. Sind sie noch nicht angemeldet, melden sie sich zuerst an und kehren automatisch zu dieser Seite zurück.
3. Die Seite zeigt die Adresse Ihrer App und was beim Erlauben passiert: Für die App wird ein neuer API-Schlüssel erstellt, die Nutzung wird ihrem BazaarLink-Guthaben belastet, und sie können den Schlüssel jederzeit widerrufen. Sie können den Schlüssel benennen und ein monatliches Ausgabenlimit festlegen (beides optional).
4. Sie klicken auf „Erlauben“ und werden zu Ihrer App zurückgeleitet. Klicken sie auf „Ablehnen“, wird kein Schlüssel erstellt, Ihre App wird nicht benachrichtigt und sie sehen die Seite „Zugriff abgelehnt“.
5. Um den Zugriff später zu widerrufen, öffnen sie die Seite „API-Schlüssel“ (https://bazaarlink.ai/keys) und deaktivieren oder löschen den nach Ihrer App benannten Schlüssel.

So funktioniert es

Schritt 1 — Authentifizierung initiieren — Generieren Sie einen zufälligen code_verifier (einen langen Zufallsstring) und dessen SHA-256-Hash als code_challenge, dann leiten Sie den Benutzer zur BazaarLink-Auth-Seite weiter.

https://bazaarlink.ai/auth?callback_url=https://yourapp.com/callback&code_challenge=CODE_CHALLENGE&code_challenge_method=S256

Parameter der Autorisierungs-URL

• callback_url (erforderlich) — wohin der Benutzer nach dem Erlauben zurückkehrt. Regeln siehe unten.
• code_challenge (erforderlich) — der base64url-kodierte SHA-256-Hash Ihres code_verifier (43 Zeichen, ohne Padding).
• code_challenge_method (erforderlich) — muss S256 sein.
• state (optional) — Ihr eigener undurchsichtiger CSRF-Wert, 1 bis 256 druckbare ASCII-Zeichen. BazaarLink gibt ihn unverändert als &state=… direkt nach dem code zurück. Ein fehlerhafter state lässt die Autorisierungsseite „Ungültige Autorisierungsanfrage“ anzeigen.
• key_label (optional) — bis zu 100 Zeichen. Füllt den Schlüsselnamen auf der Einwilligungsseite vor (der Benutzer kann ihn weiterhin ändern). Zu lange oder leere Labels werden ignoriert.
• Headless tools (CLI / desktop, no callback_url) — omit callback_url. After the user allows, the page shows a one-time code (valid 5 minutes, single use) for them to enter into your tool; exchange it exactly like a redirected code. The page cannot show which app is asking, so tell users to enter the code only in a tool they started themselves.

Nicht unterstützt

• workspace_id und required_workspace_id — nicht unterstützt. Der Schlüssel gehört immer zum eigenen Konto des Benutzers.
• code_challenge_method=plain — nicht unterstützt (nur S256).

Regeln für die callback_url

• Sie muss mit https:// beginnen. http:// wird nur für localhost, 127.0.0.1 und [::1] (beliebiger Port) akzeptiert; die Einwilligungsseite zeigt dann einen Hinweis zur lokalen Entwicklung.
• Kein Fragment (#), kein Benutzername oder Passwort in der URL, höchstens 2048 Zeichen.
• Die Einwilligungsseite zeigt den Hostnamen Ihres Callbacks, damit der Benutzer sieht, welche App anfragt.
• Nachdem der Benutzer erlaubt hat, wird der Browser mit angehängtem code=… zu Ihrer callback_url geleitet (und mit state=…, wenn Sie einen gesendet haben; ein vorhandener Query-String bleibt erhalten). Der code ist 10 Minuten gültig und nur einmal verwendbar.

Schritt 2 — Code gegen API-Schlüssel tauschen — Nachdem der Benutzer die Anfrage autorisiert hat, leitet BazaarLink mit einem einmaligen code zu Ihrer callback_url weiter. Der code ist 10 Minuten gültig und nur einmal verwendbar; ein falscher code_verifier macht ihn ungültig. Senden Sie code, code_verifier und code_challenge_method (alle drei erforderlich) per POST, um den API-Schlüssel des Benutzers zu erhalten.

curl https://bazaarlink.ai/api/v1/auth/keys \
  -H "Content-Type: application/json" \
  -d '{
    "code": "<CODE_FROM_CALLBACK_URL>",
    "code_verifier": "<CODE_VERIFIER>",
    "code_challenge_method": "S256"
  }'

# Response
# { "key": "sk-bl-...", "user_id": "..." }

Schritt 3 — Benutzerbezogenen Schlüssel verwenden — Der zurückgegebene Schlüssel ist ein normaler BazaarLink-API-Schlüssel, der dem autorisierenden Benutzer gehört — die Nutzung wird dem Guthaben dieses Benutzers belastet, nicht Ihrem.

curl https://bazaarlink.ai/api/v1/chat/completions \
  -H "Authorization: Bearer sk-bl-..." \
  -H "Content-Type: application/json" \
  -d '{"model": "google/gemini-3.5-flash", "messages": [{"role": "user", "content": "Hello"}]}'

JavaScript-Beispiel (Browser)

// 1) Create a verifier + S256 challenge, then send the user to BazaarLink
const b64url = (buf) => btoa(String.fromCharCode(...new Uint8Array(buf)))
  .replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
const verifier = b64url(crypto.getRandomValues(new Uint8Array(32)));
const challenge = b64url(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
sessionStorage.setItem("bl_verifier", verifier);
// "state" is optional: BazaarLink hands it back unchanged next to the code.
const state = b64url(crypto.getRandomValues(new Uint8Array(16)));
sessionStorage.setItem("bl_state", state);
location.href =
  "https://bazaarlink.ai/auth?callback_url=" + encodeURIComponent(location.origin + "/callback") +
  "&code_challenge=" + challenge + "&code_challenge_method=S256&state=" + state;

// 2) On /callback: check your own state, then exchange the one-time code for a user key
const params = new URLSearchParams(location.search);
if (params.get("state") !== sessionStorage.getItem("bl_state")) throw new Error("state mismatch");
const res = await fetch("https://bazaarlink.ai/api/v1/auth/keys", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    code: params.get("code"),
    code_verifier: sessionStorage.getItem("bl_verifier"),
    code_challenge_method: "S256",
  }),
});
if (!res.ok) throw new Error((await res.json()).error?.message ?? "exchange failed"); // 403 invalid_code: ask the user to authorize again
const { key } = await res.json(); // use as: Authorization: Bearer <key>

Die Seite /auth und POST /api/v1/auth/keys werden von https://bazaarlink.ai ausgeliefert (nicht von api.bazaarlink.ai). Der erhaltene Schlüssel funktioniert mit beiden Basis-URLs: https://bazaarlink.ai/api/v1 und https://api.bazaarlink.ai/v1.

Legt der Nutzer bei der Autorisierung ein Ausgabenlimit fest, ist es ein Monatslimit und wird mit dem Monatszeitraum des Kontos zurückgesetzt.

Fehler

Fehler haben das OpenAI-Format {"error":{"message","type","code"}}. POST /api/v1/auth/keys kann zurückgeben:

• 400 invalid_code_challenge_method — code_challenge_method fehlt, ist plain oder etwas anderes als S256.
• 400 — der JSON-Body ist ungültig, oder code / code_verifier fehlt.
• 403 invalid_code — der code ist unbekannt, abgelaufen oder bereits verwendet, der code_verifier ist falsch oder das Konto ist nicht mehr zugelassen. Alle diese Fälle liefern absichtlich dieselbe Meldung, damit ein Aufrufer sie nicht unterscheiden kann. Ein falscher code_verifier macht den code ebenfalls ungültig: Bitten Sie den Benutzer, erneut zu autorisieren.
• 429 rate_limited — mehr als 30 Austauschversuche in 10 Minuten von einer IP (siehe Header Retry-After).
• 429 key_total_cap — das Konto besitzt bereits die maximal zulässigen 200 API-Schlüssel.
• 405 — nur POST wird akzeptiert.

Code von Ihrem Server aus erstellen (Management-Schlüssel)

Der Inhaber eines persönlichen Management-Schlüssels kann den Autorisierungscode direkt mit POST /api/v1/auth/keys/code erstellen, ohne den Nutzer über die Browserseite zu leiten (OpenRouter-kompatibel). Der Code ist an den Inhaber des Management-Schlüssels gebunden; der Schlüssel, den Sie dafür eintauschen, ist daher ein Standardschlüssel im Konto dieses Inhabers, mit dem hier gewählten Limit, Zeitraum, Ablaufdatum und Namen. Nutzen Sie das, wenn Ihr eigenes Tool bereits einen Management-Schlüssel besitzt und einer App einen begrenzten Schlüssel übergeben will. Der Austausch (POST /api/v1/auth/keys) ist derselbe wie oben.

• callback_url (erforderlich) und code_challenge + code_challenge_method=S256 (erforderlich) — dieselben Regeln wie bei der Autorisierungs-URL.
• key_label (optional) — bis zu 100 Zeichen; der Name des Schlüssels. Standard: "App: <Ihr Callback-Host>".
• limit (optional) — Ausgabenlimit in USD, 0 oder mehr; 0 oder fehlend bedeutet kein Limit.
• usage_limit_type (optional) — daily, weekly oder monthly: wie oft das Limit zurückgesetzt wird. Wird nur zusammen mit limit verwendet; Standard ist monthly.
• expires_at (optional) — Ablaufzeitpunkt des Schlüssels: ISO-8601-UTC-Zeit mit Sekunden in der Zukunft, zum Beispiel 2026-12-31T23:59:59Z. Werte nur mit Minutengenauigkeit werden abgelehnt. Fehlt der Wert, bleibt der Schlüssel gültig, bis er widerrufen wird.
• workspace_id — nicht unterstützt (400). spawn_agent und spawn_cloud werden akzeptiert und ignoriert.

curl https://bazaarlink.ai/api/v1/auth/keys/code \
  -H "Authorization: Bearer sk-bl-YOUR_MGMT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "callback_url": "https://yourapp.com/callback",
    "code_challenge": "<CODE_CHALLENGE>",
    "code_challenge_method": "S256",
    "key_label": "My app",
    "limit": 10,
    "usage_limit_type": "monthly",
    "expires_at": "2026-12-31T23:59:59Z"
  }'

# Response
# { "data": { "id": "<ONE_TIME_CODE>", "app_id": 123456789, "created_at": "2026-10-22T12:00:00.000Z" } }
# Then POST { "code": "<ONE_TIME_CODE>", "code_verifier": "<CODE_VERIFIER>", "code_challenge_method": "S256" } to /api/v1/auth/keys

Antwort: { "data": { "id", "app_id", "created_at" } }. id ist der einmalige Code zum Eintauschen (10 Minuten gültig, nur einmal). BazaarLink hat kein App-Register, daher ist app_id eine stabile ganze Zahl, die aus Ihrer Callback-Adresse abgeleitet wird: dieselbe Adresse erhält immer dieselbe app_id.

• 401 unauthorized — kein Bearer-Schlüssel oder der Schlüssel ist unbekannt.
• 403 management_key_required — der Schlüssel ist kein persönlicher Management-Schlüssel (Standardschlüssel und Management-Schlüssel von Organisationen werden abgelehnt).
• 403 account_not_allowed — der Inhaber des Schlüssels ist gesperrt oder gelöscht.
• 400 — invalid_callback_url, invalid_code_challenge_method, invalid_code_challenge, invalid_expires_at, workspace_not_supported oder ein fehlerhafter Body.
• 429 rate_limited — mehr als 30 Codes pro Stunde für einen Inhaber oder 120 pro Stunde von einer IP (siehe Retry-After).

Der Schlüssel, den Sie erhalten

• Ein Standard-BazaarLink-API-Schlüssel (sk-bl-…), derselbe Typ wie ein auf der Seite „API-Schlüssel“ erstellter Schlüssel. Er läuft nicht von selbst ab.
• Die Nutzung wird dem BazaarLink-Guthaben des Benutzers belastet. Legt der Benutzer auf der Einwilligungsseite ein Ausgabenlimit fest, ist es ein Monatslimit.
• Er funktioniert mit beiden Basis-URLs: https://bazaarlink.ai/api/v1 und https://api.bazaarlink.ai/v1.
• Er zählt zum Limit von 200 Schlüsseln pro Konto und erscheint in der Liste „API-Schlüssel“ des Benutzers, wo er ihn jederzeit deaktivieren oder löschen kann.
• Gesperrte oder gelöschte Konten können keine Apps autorisieren, und ein vor einer Sperrung ausgestellter code wird beim Austausch abgelehnt (403 invalid_code).

Was Sie erhalten

• Authorization Code + PKCE-Flow für öffentliche Client-Anwendungen
• Abrechnung pro Benutzer: Jeder Benutzer bezahlt seine Nutzung von seinem eigenen Guthaben
• Ein eigener Schlüssel pro Benutzer, aufgeführt auf der Seite „API-Schlüssel“ des Benutzers, wo er ihn widerrufen kann

Management-API-Schlüssel

Management-Schlüssel sind für programmatische Schlüsselverwaltung konzipiert. Sie können Standard-API-Schlüssel erstellen, auflisten, aktualisieren, deaktivieren und löschen — aber keine KI-Modellaufrufe durchführen.

Management-Schlüssel erstellen

Gehen Sie zur Management API Keys-Seite und klicken Sie auf "Create" — das ist eine eigene Seite, kein Typ-Auswahlfeld auf der Standard-API-Keys-Seite.

Schlüssel auflisten

GET https://api.bazaarlink.ai/v1/keys
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# Response
{
  "keys": [
    {
      "id": "clxyz123...",
      "name": "Production Key",
      "keyType": "standard",
      "keyPrefix": "sk-bl-abc1",
      "keySuffix": "XyZ9",
      "enabled": true,
      "spendLimitUsd": 10.00,
      "spendLimitPeriod": "month",
      "expiresAt": null,
      "createdAt": "2026-01-01T00:00:00.000Z",
      "lastUsed": "2026-03-01T12:34:56.000Z",
      "requestCount": 1234,
      "totalTokens": 5678901
    }
  ]
}

Unterschlüssel erstellen

POST https://api.bazaarlink.ai/v1/keys
Authorization: Bearer sk-bl-YOUR_MGMT_KEY
Content-Type: application/json

{
  "name": "Agent Key",
  "limit": 10.00,
  "limit_reset": "monthly",
  "expires_at": "2026-12-31T23:59:59Z"
}

# limit_reset: daily | weekly | monthly
# expires_at:  ISO 8601 datetime (optional)

# Response — save the key value, it won't be shown again
{
  "id": "clxyz789...",
  "name": "Agent Key",
  "key": "sk-bl-xyz789abcdef...",
  "keyType": "standard",
  "spendLimitUsd": 10.00,
  "spendLimitPeriod": "month",
  "expiresAt": "2026-12-31T23:59:59.000Z",
  "enabled": true,
  "createdAt": "2026-03-01T00:00:00.000Z"
}

Schlüssel aktualisieren

PATCH https://api.bazaarlink.ai/v1/keys/:id
Authorization: Bearer sk-bl-YOUR_MGMT_KEY
Content-Type: application/json

{"enabled": false}              # disable key
{"spendLimitUsd": 5, "spendLimitPeriod": "week"}  # set spend limit
{"spendLimitUsd": null}         # remove spend limit
# Response: {"updated": true}

Schlüssel widerrufen

DELETE https://api.bazaarlink.ai/v1/keys/:id
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# Returns 204 No Content on success

Guthaben abfragen

GET https://api.bazaarlink.ai/v1/credits
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# Response
{
  "data": {
    "total_credits": 12.345,
    "total_usage": 3.210
  }
}

Nutzung abfragen

GET https://api.bazaarlink.ai/v1/usage?period=month
Authorization: Bearer sk-bl-YOUR_MGMT_KEY

# period: day | week | month | year

App-Zuordnung

Identifizieren Sie Ihre Anwendung in Request-Headern, um Nutzungsverfolgung, Dashboard-Sichtbarkeit und feinkörnige Analysen zu ermöglichen.

Verfügbare Header

from openai import OpenAI

client = OpenAI(
    base_url="https://api.bazaarlink.ai/v1",
    api_key="sk-bl-YOUR_KEY",
    default_headers={
        "HTTP-Referer": "https://yourapp.com",  # Optional: your site URL
        "X-Title": "My Application",             # Optional: your app name
    },
)

response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
)

Fehlercodes

Fehlerantwortformat

Fehlerhüllen unterscheiden sich je Endpunkt. Verwenden Sie HTTP-Status und, falls vorhanden, error.type. error.code kann ein String oder eine Zahl sein und fehlen; error.message dient nur der Anzeige.

{
  "error": {
    "message": "Insufficient credits. Please top up to continue.",
    "type": "invalid_request_error",
    "code": "insufficient_credits"
  }
}

HTTP Status und Fehlercode

Fehlerhüllen unterscheiden sich je Endpunkt. Verwenden Sie HTTP-Status und, falls vorhanden, error.type. error.code kann ein String oder eine Zahl sein und fehlen; error.message dient nur der Anzeige.

Maschinenlesbare Abrechnungscodes

A 402 can represent different controls. Use these stable codes to choose the correct action.

Stable error.code catalog

These string codes are emitted by public inference and media paths. Branch on the string code when present; the HTTP status remains the broad failure class.

Inhaltsmoderation

Alle Anfragen werden automatisch geprüft, bevor sie an das Modell gesendet werden. Anfragen, die gegen unsere Nutzungsrichtlinien verstoßen, werden abgelehnt, bevor sie das Modell erreichen, und geben einen 403-Fehler zurück.

Kategorien, die blockiert werden

Die Moderation basiert auf unserer Acceptable Use Policy und blockiert vor allem folgende Inhaltskategorien:

• Sexuell ausbeuterische Inhalte
• Gewaltandrohungen
• Anleitungen zu rechtswidrigen Handlungen
• Inhalte im Zusammenhang mit biologischen Gefahren

403-Antwortformat

Eine durch Moderation blockierte Anfrage gibt einen Fehler in folgendem Format zurück:

{
  "error": {
    "message": "Your prompt was blocked by content moderation.",
    "type": "invalid_request_error",
    "code": "content_filter"
  }
}

Blockierte Anfragen werden nicht abgerechnet — für eine abgelehnte Anfrage entstehen keine Kosten.

Einspruch bei Fehlalarmen

Wenn Sie glauben, dass eine Anfrage fälschlicherweise blockiert wurde, wenden Sie sich mit dem Zeitpunkt der Anfrage und (falls verfügbar) der Request-ID an den Support — wir prüfen den Fall.

Datenschutz

Anfragen werden automatisch auf Inhaltssicherheit geprüft; Text und Bilder Ihrer jüngsten Eingabe können an einen Bewertungsdienst für Inhaltssicherheit eines Dritten gesendet werden.

Bei Anfragen, die als Verstoß, Verdachtsfall, nahe am Schwellenwert oder als Stichprobe eingestuft werden, können wir den vollständigen Text oder den Anfangsteil als Compliance-Nachweis, für die Streitbeilegung und für Audits speichern; eine feste Löschfrist wird nicht zugesagt.

Bei anderen gewöhnlichen erfolgreichen Anfragen werden Prompts und Antworten nicht gespeichert; für Anfragen mit ZDR-Schlüsseln gelten die ersten beiden Punkte nicht.

Ratengrenzen, Budgets und Notbremsen

These controls can reject an otherwise valid request and require different recovery actions.

Fehlerhüllen unterscheiden sich je Endpunkt. Verwenden Sie HTTP-Status und, falls vorhanden, error.type. error.code kann ein String oder eine Zahl sein und fehlen; error.message dient nur der Anzeige.

Video- und Medienressourcenstatus

Video validation commonly returns numeric code 400. Missing jobs return 404, retired models 410, unfinished video content 409, and invalid video byte ranges 416.

Retry-Richtlinie

Retry only failures that may recover without changing the request. Honor Retry-After or use exponential backoff with jitter. Do not stack SDK and manual retries.

Fehlerbehandlung

import random
import time
from openai import OpenAI, APIStatusError

client = OpenAI(
    base_url="https://api.bazaarlink.ai/v1",
    api_key="sk-bl-YOUR_API_KEY",
    max_retries=0,  # Avoid double retries; this example handles them.
)

RETRYABLE = {429, 502, 503, 504}

for attempt in range(5):
    try:
        response = client.chat.completions.create(
            model="openai/gpt-4o",
            messages=[{"role": "user", "content": "Hello!"}],
        )
        break
    except APIStatusError as error:
        if error.status_code not in RETRYABLE or attempt == 4:
            raise
        retry_after = error.response.headers.get("Retry-After")
        delay = (
            float(retry_after)
            if retry_after
            else min(8, 0.5 * (2 ** attempt)) + random.uniform(0, 0.25)
        )
        time.sleep(delay)

Streaming-Fehlerformate

Fehler, die vor dem Streamen von Tokens auftreten, geben eine Standard-HTTP-Fehlerantwort mit einem JSON-Body zurück.

After a stream starts, the HTTP response is already 200. Parse each SSE data frame and treat a top-level error or choices[0].finish_reason === "error" as a failed, incomplete response.

Wenn ein Stream nach dem Start fehlschlägt, kann BazaarLink ein letztes SSE-Ereignis mit einem error-Objekt auf oberster Ebene senden, gefolgt von data: [DONE]. Behandeln Sie die Antwort als unvollständig und verwenden Sie Teilausgaben nicht als fertiges Ergebnis.

data: {"error":{"message":"The request could not be completed.","type":"upstream_error","code":502}}

data: [DONE]

// Branch on error.code; error.type can vary by failure path.

Tool-Aufruf

Tool Calling (auch bekannt als Function Calling) ermöglicht es Modellen, von Ihnen definierte externe Funktionen aufzurufen. Das Modell entscheidet, wann ein Tool aufgerufen wird, und generiert strukturierte Argumente — Ihr Code führt die Funktion aus und gibt Ergebnisse zurück, um die Konversation fortzusetzen.

Unterstützte Modelle

Die meisten Frontier-Modelle unterstützen Tool Calling. Hier sind einige beliebte Optionen:

Tools definieren

Jedes Tool ist ein JSON-Objekt, das eine Funktion beschreibt, die das Modell aufrufen kann. Das parameters-Feld verwendet JSON Schema.

tool_choice-Optionen

Vollständiger Ablauf

Tool Calling ist ein mehrstufiger Prozess: (1) Anfrage mit Tools senden → (2) Modell gibt tool_calls zurück → (3) Funktionen ausführen → (4) Ergebnisse zurücksenden → (5) Modell generiert finale Antwort.

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role":"user","content":"What is the weather in Taipei?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {"type": "string", "description": "City name"},
            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
          },
          "required": ["city"]
        }
      }
    }],
    "tool_choice": "auto"
  }'
# Response carries tool_calls — run get_weather() yourself, then send the
# result back with role:"tool" (same shape as the Python/TS steps 3-5) to
# get the model's final answer.

Parallele Tool-Aufrufe

Einige Modelle können mehrere Tools in einer einzigen Antwort aufrufen. Behandeln Sie jeden Tool-Aufruf und geben Sie alle Ergebnisse zurück:

# Model may return multiple tool_calls
if message.tool_calls:
    messages = [
        {"role": "user", "content": "Weather and time in Tokyo?"},
        message,
    ]

    for tool_call in message.tool_calls:
        # Execute each function
        if tool_call.function.name == "get_weather":
            result = {"temperature": 22, "condition": "Clear"}
        elif tool_call.function.name == "get_time":
            result = {"time": "2026-02-23T15:30:00+09:00"}

        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result),
        })

    # Send all results back at once
    final = client.chat.completions.create(
        model="openai/gpt-4o",
        messages=messages,
        tools=tools,
    )
    print(final.choices[0].message.content)

Tool-Aufrufe beim Streaming

Beim Streaming treffen Tool-Aufrufe als partielle, nach Position indizierte Deltas ein — sammeln Sie den Argument-String jedes Deltas nach Index, bis finish_reason zu "tool_calls" wird, was den Abschluss des Aufrufs anzeigt.

# Streaming: tool_calls arrive as partial deltas indexed by position —
# accumulate function.arguments per index until finish_reason == "tool_calls".
stream = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "What's the weather in Taipei?"}],
    tools=tools,
    tool_choice="auto",
    stream=True,
)

tool_calls = {}
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.tool_calls:
        for tc in delta.tool_calls:
            entry = tool_calls.setdefault(tc.index, {"id": "", "name": "", "arguments": ""})
            if tc.id:
                entry["id"] = tc.id
            if tc.function.name:
                entry["name"] = tc.function.name
            if tc.function.arguments:
                entry["arguments"] += tc.function.arguments
    if chunk.choices[0].finish_reason == "tool_calls":
        for call in tool_calls.values():
            print(call["name"], json.loads(call["arguments"]))

Einfache Agenten-Schleife

Ein generisches Muster, das das Modell weiter aufruft, solange es Tools anfordert, und stoppt, sobald es eine endgültige Antwort liefert — verwenden Sie max_iterations, um Endlosschleifen zu vermeiden.

# Generic loop: keep calling the model while it keeps requesting tools,
# stop once it returns a plain answer. max_iterations guards against loops.
messages = [{"role": "user", "content": "What's the weather in Taipei, and what time is it there?"}]
max_iterations = 10

for _ in range(max_iterations):
    response = client.chat.completions.create(
        model="openai/gpt-4o",
        messages=messages,
        tools=tools,
    )
    message = response.choices[0].message
    messages.append(message)

    if not message.tool_calls:
        break  # model gave a final answer

    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)
        result = TOOL_MAPPING[tool_call.function.name](**args)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result),
        })
else:
    print("Warning: max_iterations reached without a final answer")

print(messages[-1].content)

Best Practices für Funktionsdefinitionen

• Verwenden Sie spezifische, aussagekräftige Namen — get_weather_forecast statt nur weather.
• Beschreiben Sie klar, was die Funktion tut und wann sie verwendet werden soll — das Modell verlässt sich allein auf diesen Text, um zu entscheiden, ob es sie aufruft.
• Schränken Sie Werte wo möglich mit enum ein und fügen Sie in der Beschreibung ein Beispiel hinzu, um fehlerhafte Argumente zu reduzieren.
• Markieren Sie nur wirklich erforderliche Felder als required — optionale Felder sollten tatsächlich weggelassen werden können.

Strukturierte Ausgabe

Erzwingen Sie, dass das Modell gültiges JSON gemäß einem Schema zurückgibt. Dies ist essenziell für zuverlässige Anwendungen, die Modellausgaben programmatisch verarbeiten.

Methode 1: response_format (JSON Schema)

um strikte JSON-Schema-Konformität zu erzwingen:

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role":"user","content":"Review the movie Inception"}],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "movie_review",
        "strict": true,
        "schema": {
          "type": "object",
          "properties": {
            "title": {"type": "string"},
            "rating": {"type": "integer", "description": "Rating 1-10"},
            "summary": {"type": "string"},
            "pros": {"type": "array", "items": {"type": "string"}},
            "cons": {"type": "array", "items": {"type": "string"}}
          },
          "required": ["title", "rating", "summary", "pros", "cons"],
          "additionalProperties": false
        }
      }
    }
  }'

Tipps

• Verwenden Sie klare, beschreibende Eigenschaftsnamen — das Modell nutzt sie als Kontext.
• Fügen Sie Schema-Eigenschaften Beschreibungen hinzu, um das Modell zu leiten.
• Setzen Sie strict: true für garantierte Schema-Konformität (kann die Latenz leicht erhöhen).
• Halten Sie Schemas einfach — tief verschachtelte Schemas können die Ausgabequalität reduzieren.
• Testen Sie mit verschiedenen Modellen — einige verarbeiten komplexe Schemas besser als andere.

Assistant Prefill

Fügen Sie als letzten Eintrag eine unvollständige assistant-Nachricht hinzu, um auf kompatiblen Modellrouten eine Fortsetzung anzufordern.

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-4.6",
    "messages": [
      {"role":"user","content":"What is the capital of France?"},
      {"role":"assistant","content":"The capital of France is"}
    ]
  }'
# Model continues: " Paris, known for the Eiffel Tower..."

Nachrichtentransformationen

The client-supplied transforms field is ignored and removed before an upstream request. It cannot enable or disable message transformations. BazaarLink may apply context handling under its own server-side rules; shorten the input or select a model with a larger context window when needed.

Keine Datenspeicherung

Bei gewöhnlichen erfolgreichen Anfragen speichert BazaarLink Ihre Nachrichteninhalte nicht (Ausnahmen siehe Datenschutzerklärung); der ZDR-Schlüsselmodus bietet eine strengere Null-Datenspeicherung. Diese Seite beschreibt, wie Ihre Daten verarbeitet werden. Geeignet für Anwendungen, die sensible Daten verarbeiten.

Aktuelle Datenverarbeitung

• Nachrichteninhalte: bei gewöhnlichen erfolgreichen Anfragen nicht gespeichert (Ausnahmen siehe Datenschutzerklärung); ZDR-Schlüsselmodus strenger
• Nutzungsdaten für Abrechnung und Betrieb: Token-Zählungen, Zeit, Modell, Kosten, Latenz und Status
• Nutzungsprotokolle: bei gewöhnlichen erfolgreichen Anfragen nur Nutzungsstatistiken, keine Nachrichteninhalte
• Upstream-Weiterleitung: Nachrichten werden an Upstream-Anbieter weitergeleitet — unterliegen deren Datenschutzrichtlinien

Prompt-Caching

Prompt-Caching verwendet zuvor berechnete Prompt-Tokens wieder, was Kosten und Latenz erheblich reduziert — besonders für Anwendungen mit großen, wiederkehrenden System-Prompts.

Funktionsweise

Ob Konfiguration nötig ist, hängt vom Anbieter ab. Modelle der OpenAI-Familie cachen lange, wiederholte Prompt-Präfixe automatisch — ohne Änderung der Anfrage. Claude-Modelle (Anthropic) cachen nur, wenn die Anfrage einen expliziten cache_control-Breakpoint enthält; BazaarLink fügt diesen nicht selbst hinzu, ohne Markierung wird eine Claude-Anfrage nie gecacht. BazaarLink leitet vorhandene Cache-Markierungen unverändert weiter und meldet die resultierenden Cache-Read/Write-Token in der Nutzungsantwort.

# OpenAI-family models: nothing to add, long repeated prefixes cache automatically.
response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {"role": "system", "content": "You are an expert..."},  # cached automatically if long/repeated
        {"role": "user", "content": "Question here"},
    ],
)

# Check cache savings in the response usage
usage = response.usage
print(f"Prompt tokens: {usage.prompt_tokens}")
print(f"Cached tokens: {usage.prompt_tokens_details.cached_tokens}")
print(f"Cache savings: {usage.prompt_tokens_details.cached_tokens / usage.prompt_tokens * 100:.1f}%")

# Claude models: you must mark the block to cache yourself.
response = client.chat.completions.create(
    model="anthropic/claude-sonnet-4.6",
    messages=[
        {
            "role": "system",
            "content": [
                {"type": "text", "text": "You are an expert...", "cache_control": {"type": "ephemeral"}}
            ],
        },  # BazaarLink does not add cache_control on your behalf
        {"role": "user", "content": "Question here"},
    ],
)

usage = response.usage
print(f"Cache read tokens: {getattr(usage, 'cache_read_input_tokens', 0)}")
print(f"Cache write tokens: {getattr(usage, 'cache_creation_input_tokens', 0)}")

Reasoning-Tokens

Reasoning-Modelle (z.B. DeepSeek R1, o1-Serie) denken intern nach, bevor sie ihre endgültige Antwort produzieren. Diese internen Tokens werden Reasoning-Tokens genannt und separat abgerechnet.

Reasoning-Tokens aus Antworten lesen

response = client.chat.completions.create(
    model="deepseek/deepseek-r1",
    messages=[{"role": "user", "content": "Solve: if f(x) = x^2 + 3x, what is f(5)?"}],
)

# Read reasoning tokens from usage
usage = response.usage
print(f"Completion tokens: {usage.completion_tokens}")
if hasattr(usage, "completion_tokens_details"):
    details = usage.completion_tokens_details
    print(f"Reasoning tokens: {details.reasoning_tokens}")
    print(f"Output tokens: {details.accepted_prediction_tokens}")

const response = await client.chat.completions.create({
  model: "openai/gpt-5.5",
  messages: [{ role: "user", content: "Prove that sqrt(2) is irrational." }],
  // @ts-ignore - BazaarLink extension
  reasoning_effort: "high",  // low | medium | high
});

const usage = response.usage;
console.log("Reasoning tokens:", usage?.completion_tokens_details?.reasoning_tokens);

Denkmodus-Steuerung

Einige Modelle unterstützen das Umschalten ihres "Denkmodus". Der Denkmodus generiert interne Reasoning-Tokens vor der endgültigen Antwort und verbessert die Qualität auf Kosten von mehr Tokens.

# Qwen3: explicitly enable thinking mode
response = client.chat.completions.create(
    model="qwen/qwen3.7-flash",
    messages=[{"role": "user", "content": "Prove the Pythagorean theorem"}],
    extra_body={"enable_thinking": True},  # opt-in to thinking
)

# usage.completion_tokens_details.reasoning_tokens shows thinking token count

Einheitliches reasoning-Objekt (neues Format)

BazaarLink unterstützt auch das einheitliche reasoning-Objekt, das mit einer einzigen konsistenten API über alle Modellfamilien hinweg funktioniert:

// Claude extended thinking — specify thinking budget in tokens
const response = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-4.5",
  messages: [{ role: "user", content: "Prove the Pythagorean theorem" }],
  // @ts-ignore - BazaarLink extension
  reasoning: { max_tokens: 5000 },
});

// OpenAI GPT-5.6 Sol — specify effort level
const response2 = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [{ role: "user", content: "Solve this math problem..." }],
  // @ts-ignore - BazaarLink extension
  reasoning: { effort: "high" },
});

// Hide thinking content from response (model still thinks)
const response3 = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-4.5",
  messages: [{ role: "user", content: "What is 2+2?" }],
  // @ts-ignore - BazaarLink extension
  reasoning: { max_tokens: 2000, exclude: true },
});

Den Denkinhalt lesen

Ein Reasoning-Modell kann seinen Denkinhalt zusammen mit der Antwort zurückgeben. Bei den unten aufgeführten Modellen ist das Denken standardmäßig aktiv: Eine Anfrage ohne Reasoning-Parameter läuft mit aktiviertem Denken, liefert den Denkinhalt und wird für die tatsächlich verbrauchten Denk-Tokens berechnet. Mit reasoning: { exclude: true } oder include_reasoning: false schalten Sie es ab. Alle anderen Modelle liefern Denkinhalt nur auf Anfrage: senden Sie reasoning_effort, ein reasoning-Objekt, include_reasoning: true, thinking oder enable_thinking.

Modelle, die standardmäßig denken: gemini-4-argon, deepseek-v4.1-flash, deepseek-v4.1-flash-1017

So fordern Sie ihn an

Senden Sie in der Anfrage eines davon: reasoning_effort (low, medium oder high), ein reasoning-Objekt (effort, max_tokens), include_reasoning: true, thinking: { type: "enabled" } oder enable_thinking: true. Mit reasoning.exclude: true oder include_reasoning: false schalten Sie den Denkinhalt ab (das Modell denkt weiterhin).

Welche Stufen ein Modell unterstützt, sehen Sie mit GET /v1/models: Jedes Reasoning-Modell listet reasoning.supported_efforts, reasoning.default_effort und reasoning.mandatory (zum Beispiel unterstützt gemini-4-argon high, medium und low).

Beispiel: gemini-4-argon

response = client.chat.completions.create(
    model="gemini-4-argon",
    messages=[{"role": "user", "content": "Which is larger, 9.11 or 9.9?"}],
    reasoning_effort="high",  # or: extra_body={"include_reasoning": True}
)

message = response.choices[0].message
print(message.reasoning)          # the thinking text (only returned because we asked)
print(message.content)            # the answer

const stream = await client.chat.completions.create({
  model: "gemini-4-argon",
  messages: [{ role: "user", content: "Which is larger, 9.11 or 9.9?" }],
  stream: true,
  // @ts-ignore - BazaarLink extension
  reasoning: { effort: "high" },
});

for await (const chunk of stream) {
  const delta: any = chunk.choices[0]?.delta;
  if (delta?.reasoning) process.stdout.write(delta.reasoning); // thinking text
  if (delta?.content) process.stdout.write(delta.content);     // answer
}

Bei /v1/responses fordern Sie ihn mit reasoning: { effort, summary: "auto" } an; der Denkinhalt steht im reasoning-Element des output-Arrays. Bei /v1/messages erhalten Sie mit thinking: { type: "enabled", budget_tokens } thinking-Blöcke.

Latenz & Performance

Die Optimierung der KI-API-Antwortlatenz ist entscheidend für die Benutzererfahrung. Nachfolgend die Schlüsselfaktoren, die die Latenz in der BazaarLink-Architektur beeinflussen, und Best Practices zur Optimierung.

Faktoren, die die Latenz beeinflussen

• Modellgröße: größere Modelle (70B+) sind generell langsamer bei der Generierung
• Anbieterlast: variiert über Anbieter und Tageszeit hinweg
• Token-Anzahl: höhere max_tokens bedeuten längere Completion-Zeit
• Streaming vs. Non-Streaming: stream: true liefert das erste Token schneller
• Kontextlänge: sehr lange Kontexte erhöhen die Vorverarbeitungszeit

Optimierungstipps

• Bevorzugen Sie Streaming (stream: true) zur Verbesserung der gefühlten Latenz
• Wählen Sie kleinere Modelle (flash/mini/haiku) für latenzsensitive Szenarien
• Aktivieren Sie Prompt-Caching zur Latenzreduktion bei wiederholten Anfragen

import time

# Measure time to first token with streaming
start = time.time()
first_token_time = None

stream = client.chat.completions.create(
    model="google/gemini-3.5-flash",  # Fast model
    messages=[{"role": "user", "content": "Hello!"}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content and not first_token_time:
        first_token_time = time.time() - start

print(f"Time to first token: {first_token_time:.3f}s")

# Look up per-request latency and throughput after the fact, using the
# generation ID from the response (or the final streamed chunk).
curl "https://api.bazaarlink.ai/v1/generation?id=BAZAARLINK_REQUEST_ID" \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY"

# Response
{
  "data": {
    "id": "85e6f35c71a31f19-SJC",
    "model": "google/gemini-3.5-flash",
    "duration_ms": 842,
    "throughput": 61.2,
    "usage": { "prompt_tokens": 12, "completion_tokens": 48, "total_tokens": 60 }
  }
}

Verfügbarkeitsoptimierung

Nach einem Upstream-Fehler kann eine Anfrage eine andere verfügbare Quelle versuchen. Kann keine Quelle sie verarbeiten, wird ein Fehler zurückgegeben. Circuit Breaker begrenzen wiederholte Versuche; der Status der Anbieter wird überwacht.

Verfügbarkeitsmechanismen

• Circuit Breaker: erkennt und isoliert automatisch fehlgeschlagene Anbieter
• Bei einem Problem mit einer Upstream-Quelle kann die Anfrage eine andere verfügbare Quelle versuchen. Ist keine verfügbar, wird ein Fehler zurückgegeben.
• Anbieter-Gesundheitsüberwachung: verfolgt kontinuierlich Fehlerraten und Latenz pro Anbieter
• Retry-Logik: transiente Fehler (5xx) werden automatisch wiederholt

Leistungsschalter

# If an upstream source returns an error, the request can try another available source.
# Requests handled by a platform model are billed at that model's catalog price.

response = client.chat.completions.create(
    model="openai/gpt-4o",       # Primary model
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={
        "models": [              # Local fallback chain, tried in order
            "openai/gpt-4o",
            "anthropic/claude-sonnet-4.6",
            "google/gemini-3.5-flash",
        ],
    },
)

# Check whether another source handled the request (in usage logs)
# "is_failover": true indicates the primary provider was bypassed

Guardrails

Fügen Sie Ihren API-Anfragen Inhaltssicherheitsmechanismen hinzu, um schädliche Inhalte zu filtern und Compliance-Richtlinien durchzusetzen. BazaarLink bietet anpassbare Content-Filter-Guardrails derzeit nur auf Organisationsebene an; persönliche (Nicht-Organisations-) API-Schlüssel haben keine entsprechende Einstellung — die Inhaltssicherheit verlässt sich vollständig auf die eigenen integrierten Sicherheitssysteme der jeweiligen Upstream-Modellanbieter.

Geplante Funktionen (weder für persönliche noch für Organisations-Schlüssel verfügbar)

Aktuelles Verhalten

Persönliche API-Schlüssel: Alle Upstream-Anbieter haben eigene Inhaltssicherheitssysteme — Modellantworten, die Inhaltsfilter auslösen, werden mit finish_reason: "content_filter" zurückgegeben, und BazaarLink wendet keine zusätzliche Filterung an. Organisations-API-Schlüssel: org_admin kann unter "Content Filter Guardrails" benutzerdefinierte Regeln (Blockieren/Schwärzen/Protokollieren) konfigurieren, die angewendet werden, bevor der Text das Modell erreicht.

Cursor IDE Integration

Verwende BazaarLink als Cursors OpenAI Override URL. Drop-in-Setup mit automatischer Responses-API-Konvertierung, Tool-Format-Normalisierung und der bz--Präfix-Konvention für Claude-Modelle.

Schnelleinrichtung

Öffne in Cursor Einstellungen → Modelle und dann:

1. Setze Override OpenAI Base URL auf https://api.bazaarlink.ai/v1
2. Setze Override OpenAI API Key auf deinen sk-bl-... BazaarLink-Key
3. Füge den gewünschten Modellnamen hinzu — siehe unten für Claude (das bz--Präfix).

Das bz--Präfix (für Claude-Modelle)

Cursors clientseitige Validierung leitet jeden Modellnamen, der mit claude- beginnt, durch Cursors eigene Anthropic-Integration und umgeht deine Override URL. Um Cursor dazu zu bringen, die Anfrage an BazaarLink zu senden, präfixiere den Modellnamen mit bz-. Der Server entfernt das Präfix und löst den Rest über die Alias-Map auf.

Punkt- vs. Bindestrich-Varianten werden normalisiert: bz-claude-sonnet-4.6 und bz-claude-sonnet-4-6 lösen beide zum selben Modell auf.

CURSOR_MODEL_MAP-Umgebungsvariable (Betreiber-Override)

Für selbst gehostete BazaarLink-Deployments: Mit dieser Env-Var lassen sich beliebige Cursor-seitige Modellnamen auf kanonische Katalog-IDs ummappen:

CURSOR_MODEL_MAP=gpt-claude-sonnet:anthropic/claude-sonnet-4.6,gpt-opus:anthropic/claude-opus-4.7

Jetzt wird in Cursor eingegebenes gpt-claude-sonnet serverseitig auf anthropic/claude-sonnet-4.6 gemappt. Nützlich, wenn Cursor denken soll, ein Modell sei GPT-Familie (damit es durch die Override URL geroutet wird), während du tatsächlich Claude bereitstellst.

Was automatisch passiert

Wenn eine Anfrage an /v1/chat/completions geht, wendet BazaarLink folgende Kompatibilitätstransformationen transparent an — clientseitig ist nichts zu tun:

• Erkennt Responses-API-Bodies automatisch — wenn der Body input statt messages hat, wird er ins Chat-Completions-Format konvertiert (Cursor sendet das Responses-API-Format für GPT-Familien-Modelle).
• Wickelt flache Tool-Definitionen ein — Cursor Agent sendet { name, description, parameters } ohne function-Wrapper. Wir wrappen sie, damit der Upstream nicht mit Tool '' not found in provided tools ablehnt.
• Erzwingt korrektes tool_choice — Cursor sendet { type: "auto" } (Objektform, kein function). Die OpenAI-Spezifikation verlangt die String-Form für auto/none/required, daher konvertieren wir.
• Entfernt anbieterspezifische Felder, wenn der Upstream sie nicht unterstützt — parallel_tool_calls, logprobs, top_logprobs, logit_bias, service_tier, user werden vor dem Weiterleiten entfernt (sonst gibt der Upstream 400 zurück).
• Mappt max_output_tokens → max_tokens und entfernt Responses-API-spezifische Felder (previous_response_id, truncation, background, store). Das reasoning-Feld bleibt für Chat-Completions-native Bodies erhalten.

Cursor-Agent-Modus

Tool-Calling läuft über den Standard-Chat-Completions-Tool-Call-Flow. Cursor sendet tools (Shell, Read, Write, Grep etc.) mit tool_choice: "auto"; BazaarLink leitet an den Anbieter des gewählten Modells weiter, der entscheidet, ob ein Tool aufgerufen wird. Tool-Aufrufe kommen als Standard-OpenAI-tool_calls-Deltas zurück; Cursor führt lokal aus und setzt das Gespräch fort. Funktioniert gleich, ob du gpt-4o (nativ OpenAI) oder bz-claude-sonnet-4.6 wählst.

Modell-Routing

BazaarLink verwendet das Format provider/model-name, um Anfragen an den richtigen Upstream-Anbieter weiterzuleiten. Dies gibt Ihnen Zugang zu allen gängigen Modellen über einen einzigen API-Endpunkt.

Modell-ID-Format

{provider}/{model-name}

# Examples
openai/gpt-5.4-mini
anthropic/claude-sonnet-4.6
google/gemini-3-flash-preview
deepseek/deepseek-v4.1-flash

Routing-Priorität

Wenn Sie eine Anfrage senden, löst BazaarLink den Upstream-Anbieter in dieser Reihenfolge auf:

1. Exakte Übereinstimmung — sucht nach einer Modellroute, die der vollständigen Modell-ID entspricht
2. Anbieter-Wildcard — fällt auf provider/*-Routen zurück (z.B. openai/*)
3. Globale Wildcard — fällt auf *-Wildcard-Routen zurück
4. Standard-Anbieterschlüssel — nur für bekannte Katalogmodelle; verwendet aktivierte, als Standard markierte Schlüssel

Alle verfügbaren Modelle durchsuchen auf der Modellseite.

Auto Router

Auto Router v3 bewertet die Anfrage in eine von 14 Aufgabenstufen und verwendet dann die aktuell konfigurierte Primary- und Fallback-Kette dieser Stufe. Bezahlte und kostenlose Tabellen werden im Admin getrennt verwaltet.

• auto — verwendet die bezahlte Routing-Tabelle; das erfolgreiche tatsächliche Modell wird zum veröffentlichten Preis berechnet.
• auto:free — verwendet die kostenlose Routing-Tabelle; innerhalb des Kontingents kostet der Aufruf 0 USD. Danach können Konten mit Guthaben zu bezahltem auto wechseln, sofern der bezahlte Fallback nicht deaktiviert ist.

Verwendung

Setzen Sie das Modell auf "auto" (kostenpflichtig) oder "auto:free" (kostenlos), um automatisches Routing zu aktivieren:

curl https://api.bazaarlink.ai/v1/chat/completions \
  -H "Authorization: Bearer $BAZAARLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","messages":[{"role":"user","content":"Review this TypeScript function"}]}'

Wie v3 eine Stufe auswählt

Allgemeine Stufen: simple, standard, complex, reasoning. Spezialstufen: coding, vision, image, video, data, search, social, email, calendar, trading. Ergebnisse an einer unsicheren Grenze werden um eine Stufe angehoben.

• Tier-Bewertung: messages, tools, Länge, Schlüsselwörter und Struktur wählen eine von 14 Stufen
• Feste Regeln: Bild-, formale Denk- und Spezialaufgaben können eine Stufe direkt wählen
• Route-Lookup: liest Primary und bis zu fünf Fallbacks; eine deaktivierte Stufe liefert 503
• Ausführung: versucht Primary und danach die Fallbacks in konfigurierter Reihenfolge
• Antwortverfolgung: das aufgelöste Modell wird im Antwort-Body und X-Auto-Resolved-Model-Header zurückgegeben

Aktuelle Modelltabellen

Die Tabellen lesen dieselbe Live-Konfiguration wie Inferenz und Admin. Primary, Fallback-Reihenfolge und Status jeder Stufe können ohne Deployment geändert werden.

auto

auto:free

Ausgewählte Modelle bieten ein ratenbegrenztes kostenloses Kontingent. Die Berechtigung wird pro Modell von der Plattform vergeben — rufen Sie das Modell mit seiner regulären ID auf; das Suffix :free ist ein optionaler Alias (bei einem kostenpflichtigen Modell macht es dieses nicht kostenlos).

Modellvarianten

Unabhängige Modell-IDs

Katalogvarianten wie :free, :extended und :thinking können Einträge mit unterschiedlichen Funktionen oder Katalogpreisen kennzeichnen. Upstream-Route und Kundenpreis werden durch den BazaarLink-Katalog und serverseitige Regeln bestimmt.

:free
:extended
:thinking

:nitro
:floor
:exacto

:online

Kostenlose Modelle

Ausgewählte Modelle bieten ein ratenbegrenztes kostenloses Kontingent. Die Berechtigung wird pro Modell von der Plattform vergeben — rufen Sie das Modell mit seiner regulären ID auf; das Suffix :free ist ein optionaler Alias (bei einem kostenpflichtigen Modell macht es dieses nicht kostenlos).

• Rufen Sie die reguläre Modell-ID auf (z. B. deepseek/deepseek-v4-flash). Anfragen innerhalb des kostenlosen Kontingents werden automatisch kostenlos bedient.
• Die kostenlose Nutzung ist pro Nutzer durch Anfragen pro Minute und ein Tageslimit begrenzt. Die Limits skalieren mit der Kontostufe (kein Guthaben / mit Guthaben).
• Wenn Sie das kostenlose Kontingent überschreiten und Guthaben haben, laufen Anfragen automatisch zum gelisteten Preis auf der bezahlten Stufe weiter. Senden Sie X-Free-Fallback: false, um den automatischen Fallback zu deaktivieren und stattdessen 429 zu erhalten. Ohne Guthaben liefern Anfragen über dem Kontingent 429.
• GET /v1/models listet für jedes Modell mit kostenlosem Kontingent einen :free-Eintrag; auto:free routet immer zu einem kostenlosen Modell.

Modelle mit kostenlosem Kontingent

Diese Modell-IDs direkt aufrufen, um das kostenlose Kontingent zu nutzen. Die Liste ändert sich mit dem Angebot — die aktuelle Fassung liefert die API.

qwen/qwen3.7-flash
reflection/beam-free
stealth/glyph-cluster
nvidia/nemotron-3.5-lightning-free
inclusionai/ling-3.1-flash-1019
deepseek/deepseek-v4-flash-0731free

Grenzen des kostenlosen Kontingents

Tagesbudget = obiges Anfragebudget × Kontostufen-Multiplikator, je kostenlosem Modell getrennt gezählt. Für auto:free gilt zusätzlich eine parallele Obergrenze pro IP. Einzelne Modelle können strengere oder großzügigere Limits haben; die effektiven Werte zeigt der Block „Kostenloses Kontingent“ auf der Modellseite. Das kostenlose Kontingent wird in Einheiten gemessen, nicht in reinen Anfragezahlen: Die pro Anfrage verbrauchten Einheiten steigen mit der Kontextlänge des Prompts. Bei gleichem Tageskontingent sind mit langen Kontexten daher deutlich weniger Anfragen möglich als mit kurzen Prompts.

Nach dem Aufbrauchen des Kontingents

Nach dem Verbrauch des kostenlosen Kontingents werden weitere Anfragen zum angegebenen Modellpreis abgerechnet, sofern das Konto Guthaben hat. Sende `X-Free-Fallback: false` oder deaktiviere den Wechsel in den kostenpflichtigen Tarif in den Schlüsseleinstellungen, um stattdessen 429 zu erhalten. Ohne Guthaben geben Anfragen über dem Kontingent 429 zurück.

Wird eine Anfrage tatsächlich so herabgestuft, trägt die Antwort einen Header x-bl-free-fallback: daily oder x-bl-free-fallback: rpm, der angibt, welches Limit ausgelöst hat — so erkennst du den Wechsel schon zum Zeitpunkt der Anfrage und nicht erst an der Rechnung. Bei nicht herabgestuften Anfragen fehlt dieser Header.

# Return 429 instead of switching to paid routing
-H "X-Free-Fallback: false"

Organisationsverwaltung

BazaarLink-Organisationen verwenden eine dreistufige Architektur: Organisation → Team → Mitglied. Guthaben wird auf Org-Ebene gespeichert; jedes Team und Mitglied kann ein monatliches Ausgabenlimit haben. API-Anfragen prüfen Mitglied → Team → Org-Guthaben in Reihenfolge.

Dreistufiges Budgetsystem

Bei jeder API-Anfrage werden drei Budgetebenen der Reihe nach geprüft. Überschreitung einer Ebene gibt HTTP 429 zurück:

1. Monatliches Mitgliederbudget (OrgMember.monthlyBudget)
2. Monatliches Teambudget (Team.monthlyBudget)
3. Org-Guthabenstand (Organization.credits)

Nutzungsberichte

Die Berichtsseite im Org-Portal bietet monatliche Ausgabenanalysen über vier Dimensionen:

• Übersicht: Gesamtausgaben, Margenrate, täglicher Trendchart
• Nach Team: Ausgaben pro Team, Anteil %, Modellaufschlüsselung, Budgetauslastung
• Nach Modell: Ausgaben pro Modell, Durchschnittspreis ($/1M Tokens)
• Nach Mitglied: Ausgaben pro Mitglied — nur org_admin

Alle Ansichten unterstützen CSV-Export mit BOM-Präfix für direkte Excel-Kompatibilität.

Organisationen erstellen & verwalten

1. Gehen Sie zu Einstellungen → Organisationen → Neue Organisation erstellen
2. Erstellen Sie Teams im Org-Portal (optional: Kostenstelle und Monatsbudget)
3. Laden Sie Mitglieder per E-Mail ein, weisen Sie eine Rolle und ein Team zu
4. Stellen Sie API-Schlüssel für Mitglieder aus — die Nutzung wird automatisch dem korrekten Team/Mitglied zugeordnet
5. Sehen Sie die Berichtsseite für monatliche Ausgaben aufgeschlüsselt nach Team, Modell oder Mitglied
6. Sehen Sie sich die Seite „Berichte“ für die monatlichen Ausgaben an, aufgeschlüsselt nach Team, Modell oder Mitglied

Mitgliederrollen

Was kann eine Organisation sonst noch verwalten?

Über Mitglieder und Teams hinaus bietet der Bereich Organisationsmanagement:

• API keys and model restrictions
• Content filtering before text reaches a model
• Allowed Models by organization, team, member, or key
• Monthly budgets and spend emergency brakes
• Reports and billing
• Change logs and security logs

curl https://api.bazaarlink.ai/v1/orgs \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY"

# Create a team
curl https://api.bazaarlink.ai/v1/orgs/{orgId}/teams \
  -X POST \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Engineering", "costCenterCode": "ENG-001", "monthlyBudget": 500}'

# Add a member
curl https://api.bazaarlink.ai/v1/orgs/{orgId}/members \
  -X POST \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "alice@example.com", "role": "member", "monthlyBudget": 50}'

# Remove a member
curl https://api.bazaarlink.ai/v1/orgs/{orgId}/members/{memberId} \
  -X DELETE \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY"

# Monthly overview via management key
curl "https://bazaarlink.ai/api/orgs/{orgId}/reports/overview?year=2026&month=3" \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY"

# By-team breakdown
curl "https://bazaarlink.ai/api/orgs/{orgId}/reports/by-team?year=2026&month=3" \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY"

# Export CSV (downloads file)
curl "https://bazaarlink.ai/api/orgs/{orgId}/reports/export?year=2026&month=3&view=by-team" \
  -H "Authorization: Bearer sk-bl-YOUR_MANAGEMENT_KEY" \
  -o report.csv

Fehlerantwort-Referenz

Erlaubte Modelle (Whitelist)

Schränken Sie ein, welche Modelle Ihre Organisation, Teams oder einzelne Mitglieder aufrufen dürfen. Nützlich, um teure oder ungeprüfte Modelle zu blockieren, Modellstandards durchzusetzen oder ein Team auf einen einzigen Provider zu beschränken.

So funktioniert es

• Drei unabhängige Ebenen — Organisation, Team, Mitglied — jede führt ihre eigene Liste (String[] in der Datenbank).
• Wenn alle drei Ebenen leer sind, sind alle Modelle erlaubt (Standardverhalten).
• Wenn eine oder mehrere Ebenen nicht leer sind, ist die effektive Liste die Schnittmenge der nicht leeren Ebenen — ein Modell muss auf jeder eingeschränkten Ebene erlaubt sein, um durchzukommen.
• Änderungen werden innerhalb weniger Sekunden wirksam (60s In-Memory + 5min Redis-Cache; beide werden bei einer Aktualisierung geleert).

Musterformat

• Exakte Übereinstimmung — z. B. openai/gpt-4o (nur genau dieses Modell).
• Provider-Wildcard — z. B. openai/* (jedes Modell unter dem openai/-Präfix).
• Nur Kleinbuchstaben. Maximal 200 Einträge pro Liste, 100 Zeichen pro Eintrag.

Wo verwalten

Org-Portal → Erlaubte Modelle. org_admin kann Org-, Team- und Mitgliederlisten bearbeiten; team_admin kann das eigene Team und dessen Mitglieder bearbeiten.

Fehlerantwort bei Blockierung

Aufrufe an ein nicht erlaubtes Modell geben HTTP 403 mit folgendem Body zurück:

HTTP/1.1 403 Forbidden
Content-Type: application/json

{
  "error": {
    "message": "Model is not allowed for this account",
    "code": "model_not_allowed"
  }
}

Verwaltungs-API

Alle Endpunkte akzeptieren Web-Session oder Bearer Management Key (sk-bl-...). PATCH ersetzt die gesamte Liste; übergeben Sie [], um sie zu leeren.

# Org-level list
GET    /api/orgs/:orgId/allowed-models
PATCH  /api/orgs/:orgId/allowed-models

# Team-level list
GET    /api/orgs/:orgId/teams/:teamId/allowed-models
PATCH  /api/orgs/:orgId/teams/:teamId/allowed-models

# Member-level list
GET    /api/orgs/:orgId/members/:memberId/allowed-models
PATCH  /api/orgs/:orgId/members/:memberId/allowed-models

# Example: restrict an org to OpenAI + a specific Anthropic model
curl -X PATCH https://bazaarlink.ai/api/orgs/$ORG_ID/allowed-models \
  -H "Authorization: Bearer sk-bl-..." \
  -H "Content-Type: application/json" \
  -d '{"allowedModels": ["openai/*", "anthropic/claude-sonnet-4.6"]}'

Circuit Breaker (Ausgaben-Notabschaltung)

Eine doppelte Ausgabenobergrenze, die weitere Anfragen blockiert, wenn die Upstream-Kosten in die Höhe schnellen. Entwickelt, um außer Kontrolle geratene Skripte, Endlosschleifen oder Missbrauch gestohlener Schlüssel einzudämmen, bevor sie echtes Geld kosten.

So funktioniert es

• Pro Scope werden zwei feste Fenster in Redis verfolgt: 1-Minuten- und 1-Stunden-Upstream-Kosten (USD).
• Wenn die Ausgaben in einem der Fenster den Schwellenwert erreichen, werden alle nachfolgenden Anfragen in diesem Scope abgelehnt, bis das Fenster zurückgesetzt wird.
• Standardwerte: 5 $ / Minute, 20 $ / Stunde. Standardmäßig deaktiviert — muss aktiv eingeschaltet werden.
• Zähler leben in Redis mit TTL — die Wiederherstellung erfolgt automatisch, kein manuelles Zurücksetzen für Org-/Team-/Member-Trips erforderlich.

Scopes (Member überschreibt Team überschreibt Org)

Jede Ebene kann eigene Schwellenwerte setzen. Auflösungsreihenfolge ist Member → Team → Org → Plattform-Standard — der erste nicht-null Wert pro Feld gewinnt (cbEnabled, cbMinuteUsd, cbHourlyUsd).

• Org-Ebene — gilt für alle Schlüssel der Organisation. Eingestellt im Org-Portal → Circuit Breaker.
• Team-Ebene — gilt für alle Schlüssel, die diesem Team zugewiesen sind. Überschreibt Org für diese Schlüssel.
• Member-Ebene — gilt nur für Schlüssel, die diesem Mitglied zugewiesen sind. Überschreibt Team und Org.

Auslöseverhalten

Bei Auslösung schlagen Anfragen schnell fehl (es wird kein Upstream-Aufruf getätigt). Die Antwort ist HTTP 429 mit folgendem Body:

HTTP/1.1 429 Too Many Requests
Content-Type: application/json

{
  "error": {
    "message": "Spend circuit breaker tripped at member scope (minute window: $5.2341 ≥ $5.00). Try again later or contact your organization owner."
  }
}

Audit-Log

Jedes Auslöseereignis und jede Konfigurationsänderung wird aufgezeichnet:

• Auslöseereignisse — Aktionen org.cb.tripped / team.cb.tripped / org_member.cb.tripped. Dedupliziert auf einen Eintrag pro Scope+Fenster pro Stunde, sodass eine anhaltende Auslösung das Log nicht überflutet.
• Konfigurationsänderungen — Aktionen org.cb.update / team.cb.update / org_member.cb.update. Erfassen Vorher/Nachher-Werte sowie den Akteur.

Verwaltungs-API

Org-Admins können Einstellungen über die API lesen und aktualisieren. Alle Endpunkte akzeptieren Web-Session oder Bearer Management Key (sk-bl-...). Senden Sie eine beliebige Teilmenge von Feldern im PATCH-Body; null löscht ein Feld und fällt auf die übergeordnete Ebene zurück.

# Org-level config
GET    /api/orgs/:orgId/circuit-breaker
PATCH  /api/orgs/:orgId/circuit-breaker

# Team-level config
GET    /api/orgs/:orgId/teams/:teamId/circuit-breaker
PATCH  /api/orgs/:orgId/teams/:teamId/circuit-breaker

# Member-level config
GET    /api/orgs/:orgId/members/:memberId/circuit-breaker
PATCH  /api/orgs/:orgId/members/:memberId/circuit-breaker

# Example: tighten the org-level cap to $2/min, $10/hr
curl -X PATCH https://bazaarlink.ai/api/orgs/$ORG_ID/circuit-breaker \
  -H "Authorization: Bearer sk-bl-..." \
  -H "Content-Type: application/json" \
  -d '{"cbMinuteUsd": 2, "cbHourlyUsd": 10, "cbEnabled": true}'

# GET response (org scope)
{
  "settings":         { "cbEnabled": true, "cbMinuteUsd": 2,  "cbHourlyUsd": 10  },
  "resolvedSettings": { "cbEnabled": true, "cbMinuteUsd": 2,  "cbHourlyUsd": 10  },
  "liveSpend":        { "minuteSpend": 0.4123, "hourSpend": 3.8721 }
}

API-Schlüssel-Rotation

Der regelmäßige Austausch von API-Schlüsseln ist eine Sicherheitsmaßnahme. Erstellen Sie einen neuen Schlüssel, aktualisieren und prüfen Sie Ihre Integration und widerrufen Sie danach den alten Schlüssel. Ein ausfallfreier Ablauf wird nicht garantiert.

Rotationsschritte

1. Neuen API-Schlüssel erstellen
2. Anwendung oder Umgebungsvariablen auf den neuen Schlüssel aktualisieren
3. Verifizieren, dass der neue Schlüssel korrekt funktioniert
4. Alten Schlüssel deaktivieren oder löschen

# Key CRUD via Bearer auth requires a MANAGEMENT key (keyType: "management").
# Standard keys get 403 on /v1/keys — create a management key first,
# or rotate keys from the dashboard UI instead.

# Step 1: Create new key (management key auth)
POST https://api.bazaarlink.ai/v1/keys
Authorization: Bearer $BL_MANAGEMENT_KEY
{"name": "Production v2"}
# → saves new key: sk-bl-NEW_KEY_VALUE

# Step 2: Update your application
# export BAZAARLINK_API_KEY=sk-bl-NEW_KEY_VALUE

# Step 3: Verify new key works
curl https://api.bazaarlink.ai/v1/models \
  -H "Authorization: Bearer sk-bl-NEW_KEY_VALUE"

# Step 4: Revoke old key (management key auth again)
DELETE https://api.bazaarlink.ai/v1/keys/:old_key_id
Authorization: Bearer $BL_MANAGEMENT_KEY

Aktivitätsexport

Laden Sie Ihren vollständigen API-Nutzungsverlauf als CSV für Finanzprüfungen, Kostenanalysen oder Compliance-Berichte herunter.

CSV-Export

Melden Sie sich an und gehen Sie zur Protokolle-Seite. Klicken Sie auf die CSV-Export-Schaltfläche in der oberen rechten Ecke, um Ihren vollständigen Verlauf als CSV-Datei herunterzuladen. Kein API-Aufruf erforderlich.

CSV-Spalten

JSON-Nutzungs-API

Für programmatischen Zugriff fragen Sie aggregierte Statistiken nach Zeitraum, Modell oder Schlüssel ab:

# Query usage data (grouped / aggregated)
GET https://api.bazaarlink.ai/v1/usage
Authorization: Bearer sk-bl-YOUR_KEY

# With period filtering (day | week | month | year)
GET https://api.bazaarlink.ai/v1/usage?period=month

# Response
{
  "period": "month",
  "since": "2025-01-01T00:00:00.000Z",
  "credits": 10.5000,
  "totals": {
    "spend": 0.1812,
    "requests": 309,
    "tokens": 161200,
    "promptTokens": 95000,
    "completionTokens": 66200
  },
  "byModel": [{ "model": "openai/gpt-4o", "spend": 0.0028, "tokens": 1200, "requests": 5 }],
  "byKey":   [{ "keyName": "My Agent", "spend": 0.0028, "tokens": 1200, "requests": 5 }],
  "byApp":   [{ "appName": "MyApp", "spend": 0.0015, "tokens": 600, "requests": 3 }],
  "timeSeries": [{ "date": "2025-01-15", "model": "openai/gpt-4o", "cost": 0.0012, "tokens": 500, "requests": 2 }]
}

Nutzungsabrechnung

Fragen Sie detaillierte Nutzungsstatistiken über die API ab, einschließlich Token-Verbrauch, Kostenanalyse und Anfrageverlauf.

Antwortfeld-Referenz

import httpx

# Aggregated stats (Bearer token — period: day | week | month | year)
response = httpx.get(
    "https://api.bazaarlink.ai/v1/usage",
    headers={"Authorization": "Bearer sk-bl-YOUR_KEY"},
    params={"period": "month"},
)

data = response.json()
totals = data["totals"]
print("This month: US$%.4f  (%d requests)" % (totals["spend"], totals["requests"]))

# Cost breakdown by model
for m in data["byModel"]:
    print("  %s: US$%.4f  (%d reqs, %d tokens)" % (m["model"], m["spend"], m["requests"], m["tokens"]))

Feedback melden

Helfen Sie uns, BazaarLink zu verbessern, indem Sie Probleme, Fehler oder Vorschläge melden. Wir überwachen aktiv alle Feedback-Kanäle.

So melden Sie

Was Sie einschließen sollten

• Anfrage-ID (aus dem Antwort-id-Feld)
• Verwendetes Modell und gesendete Parameter
• Erwartetes vs. tatsächliches Verhalten
• Zeitstempel und Häufigkeit des Problems
• Fehlermeldungen oder HTTP-Statuscodes

Besuchen Sie unsere Kontaktseite, um Feedback zu senden.

FAQ