API DocsChat API

Chat API

Chat Completions, Messages (Anthropic) und Responses. OpenAI- und Anthropic-Drop-in, Streaming, Function Calling.

Endpunkt

Sende Chat-Nachrichten und erhalte eine KI-generierte Antwort.

POST/api/v1/llm/chat/completions

SDK-Kompatibilität

Dieser Endpunkt ist vollständig kompatibel mit dem OpenAI-Chat-Format — du kannst bestehende SDKs verwenden.

Parameter

Parameter	Type	Default	Description
`model`required	`string`	-	ID des Modells, z.B. gpt-4o oder claude-sonnet-4-20250514.
`messages`required	`array`	-	Array von Nachrichten mit role und content.
`stream`	`boolean`	`false`	Wenn true, wird die Antwort per SSE gestreamt.
`temperature`	`number`	`1`	Kreativität der Antwort (0–2). Niedrigere Werte = fokussierter.
`max_tokens`	`integer`	-	Maximale Anzahl an Tokens in der Antwort.
`top_p`	`number`	`1`	Nucleus-Sampling — Alternative zu temperature.
`response_format`	`object`	-	Erzwingt ein bestimmtes Ausgabeformat (z.B. JSON).
`tools`	`array`	-	Liste von Tools/Funktionen, die das Modell aufrufen kann.
`tool_choice`	`string`	-	Steuert, ob und welche Tools aufgerufen werden.
`frequency_penalty`	`number`	`0`	Bestraft häufig verwendete Tokens (-2 bis 2).
`presence_penalty`	`number`	`0`	Bestraft bereits verwendete Tokens (-2 bis 2).
`stop`	`string \| array`	-	Sequenzen, bei denen die Generierung stoppt.

Nachrichtenformat

Jede Nachricht hat eine Rolle (system, user, assistant) und einen Inhalt.

Beispiel einer Nachricht

[
  {
    "role": "system",
    "content": "You are a helpful assistant."
  },
  {
    "role": "user",
    "content": "What is the capital of France?"
  },
  {
    "role": "assistant",
    "content": "The capital of France is Paris."
  },
  {
    "role": "user",
    "content": "And Germany?"
  }
]

Einfacher Request

Minimaler Request mit einer User-Nachricht.

1curl -X POST https://app.anymize.ai/api/v1/llm/chat/completions \
2  -H "Authorization: Bearer YOUR_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "fountain-1.0",
6    "messages": [
7      {"role": "system", "content": "You are a helpful assistant."},
8      {"role": "user", "content": "Explain quantum computing in one sentence."}
9    ],
10    "temperature": 0.7,
11    "max_tokens": 256
12  }'

Antwort

Die Antwort enthält die generierte Nachricht, Modell-Info und Token-Verbrauch.

200OK

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1700000000,
  "model": "fountain-1.0",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Quantum computing uses quantum-mechanical phenomena like superposition and entanglement to process information in ways that classical computers cannot."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 28,
    "completion_tokens": 24,
    "total_tokens": 52
  }
}

Token-Verbrauch

Jede Antwort enthält prompt_tokens, completion_tokens und total_tokens.

Umgang mit anonymisierten Platzhaltern

Wenn du voranonymisierte Texte an den normalen Chat-Endpoint schickst, muss das Modell die [[Typ-HASH]] Platzhalter exakt beibehalten. Füge dazu den folgenden System-Prompt hinzu.

Ohne Prompt

Sehr geehrter [Name anonymisiert], bezüglich Ihres Anliegens...

Mit Prompt

Sehr geehrter Herr [[Person-ABC123]], bezüglich Ihres Anliegens...

Ohne explizite Anweisung ersetzt das Modell die Platzhalter durch generische Beschreibungen wie '[anonymisiert]'. Das zerstört die Zuordnung für die De-Anonymisierung.

Wenn du voranonymisierte Texte verarbeitest, füge diesen Teil zu deinem System-Prompt hinzu:

System-Prompt für Platzhalter

1const response = await client.chat.completions.create({
2  model: "fountain-1.0",
3  messages: [
4    {
5      role: "system",
6      content: `## CRITICAL RULE: ANONYMIZATION PLACEHOLDERS
7
8The user's messages contain anonymized placeholders shaped [[<Type>-<HASH>]],
9where <Type> is the PII category (person, email, iban, telephone_number, ...)
10and <HASH> is a short random code.
11
12FORBIDDEN:
13- Writing "[Name anonymisiert]" or "[anonymized]"
14- Describing WHAT the placeholder is instead of USING it
15- Writing a double-bracket token that was NOT in the user's message — the hash
16  is a database key, so an invented one resolves to nothing.
17
18REQUIRED:
19- Copy each placeholder character-for-character from the user's message
20- Use it inline like the real value: "Herr <placeholder> hat..."
21- Need a value the user never gave you? Use SINGLE brackets ([Name]).
22
23WHY: After your response, placeholders get replaced with real values.`,
24    },
25    {
26      role: "user",
27      content: "Schreibe eine E-Mail an [[Person-ABC123]] bezuglich dem Vertrag.",
28    },
29  ],
30})
31
32// Model responds: "Sehr geehrter Herr [[Person-ABC123]], ..."
33// After de-anonymization: "Sehr geehrter Herr Max Mustermann, ..."

Oder nutze den anonymen Endpoint

Beim anonymen Endpoint (/api/v1/llm-anonymous) wird dieser System-Prompt automatisch injiziert. Du musst ihn dort nicht selbst hinzufügen.

Messages API

Endpunkt

POST /api/v1/messages ist der Anthropic-Pfad. Base URL https://app.anymize.ai/api, dann ruft der Client /v1/messages auf. Dieselbe Anonymisierung, dieselben Credits, dieselben Modelle wie bei Chat Completions.

POST/api/v1/messages

SDK-Kompatibilität

Drop-in für Claude Code, das offizielle Anthropic SDK und @ai-sdk/anthropic. Auth per Bearer oder x-api-key. Streaming per SSE mit den Anthropic Event-Namen.

Pfad-Aliase

Drei Pfade, ein Handler. So landen alle gängigen Base-URL-Konventionen auf derselben Pipeline.

Anthropic SDK / Claude Codehttps://app.anymize.ai/api/v1/messages

AI SDK neben Completionshttps://app.anymize.ai/api/v1/llm/messages

OpenAI-Base bleibt stehenhttps://app.anymize.ai/api/v1/llm/v1/messages

Auth

Authorization: Bearer ANYM_... oder x-api-key: ANYM_... Claude Code muss ANTHROPIC_AUTH_TOKEN nutzen (Bearer). ANTHROPIC_API_KEY schickt x-api-key und scheitert an manchen Custom-Gateway-Pfaden. Unset ANTHROPIC_API_KEY, wenn du umstellst.

1-H "Authorization: Bearer YOUR_API_KEY"

Parameter

Parameter	Type	Default	Description
`model`required	`string`	-	Modell-ID, z. B. anthropic/claude-sonnet-4.6 oder openai/gpt-5.4. Dieselben IDs wie bei Chat Completions.
`messages`required	`array`	-	Array aus user- und assistant-Nachrichten. Content als String oder Blocks (text, image, tool_use, tool_result).
`max_tokens`required	`integer`	`4096`	Pflichtfeld bei Anthropic. Wenn es fehlt, setzt anymize 4096.
`system`	`string \| array`	-	String oder Array aus Text-Blocks. Wird zur OpenAI-System-Message.
`stream`	`boolean`	`false`	true liefert Anthropic SSE. Usage kommt im message_delta.
`temperature`	`number`	-	Kreativität der Antwort (0-2). Wird 1:1 an Completions durchgereicht.
`top_p`	`number`	-	Nucleus-Sampling. Wird 1:1 an Completions durchgereicht.
`tools`	`array`	-	Anthropic tools (name + input_schema) und Client-Tools wie bash_20250124. Werden zu OpenAI functions.
`tool_choice`	`object`	-	auto, any (required), none oder ein konkretes Tool per Name.
`stop_sequences`	`array`	-	stop_sequences werden zu OpenAI stop.
`thinking`	`object`	-	thinking.budget_tokens mappt auf reasoning.effort (low / medium / high).

Request

1curl https://app.anymize.ai/api/v1/messages \
2  -H "x-api-key: YOUR_API_KEY" \
3  -H "anthropic-version: 2023-06-01" \
4  -H "content-type: application/json" \
5  -d '{
6    "model": "anthropic/claude-haiku-4.5",
7    "max_tokens": 256,
8    "messages": [{ "role": "user", "content": "Hello" }]
9  }'

Antwort

Anthropic Message: id, role assistant, content-Blocks, stop_reason, usage.input_tokens / output_tokens.

200Response

{
  "id": "msg_01abc",
  "type": "message",
  "role": "assistant",
  "model": "anthropic/claude-haiku-4.5",
  "content": [
    {
      "type": "text",
      "text": "Hello"
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 12,
    "output_tokens": 4
  }
}

Streaming

Der Stream folgt Anthropic: message_start, content_block_start/delta/stop, message_delta (Usage + Stop-Reason), message_stop. Tool-Calls kommen als tool_use-Blocks mit partial_json.

count_tokens

POST .../count_tokens schätzt Input-Tokens lokal, ohne Credits. Claude Code und das SDK rufen das vor dem eigentlichen Request. Die Abrechnung läuft weiter über Completions.

POST/api/v1/messages/count_tokens

Modelle listen

GET /api/v1/models mit Header anthropic-version (und GET /api/v1/llm/v1/models) liefert die Anthropic-Liste mit data und has_more. Dieselben IDs wie GET /api/v1/llm/models. Der In-App-Picker ohne diesen Header bleibt unverändert.

GET/api/v1/models

GET /api/v1/llm/v1/models

Claude Code

ANTHROPIC_BASE_URL=https://app.anymize.ai/api und ANTHROPIC_AUTH_TOKEN gleich deinem Key. Modell z. B. anthropic/claude-sonnet-4.6. Details stehen unter SDKs und unter Integration.

Streaming

Streaming aktivieren

Setze stream: true im Request, um Antworten in Echtzeit zu empfangen.

POST/api/v1/llm/chat/completions

"stream": true

SSE-Format

Antworten kommen als Server-Sent Events — ein Chunk pro Zeile mit data:-Prefix.

Beispiel-Chunk

data: {"id": "chatcmpl-abc123","object": "chat.completion.chunk","created": 1700000000,"model": "fountain-1.0","choices":[{"index": 0,"delta":{"content": "Hello"},"finish_reason": null}]}

data: {"id": "chatcmpl-abc123","object": "chat.completion.chunk","created": 1700000000,"model": "fountain-1.0","choices":[{"index": 0,"delta":{"content": " world"},"finish_reason": null}]}

data: {"id": "chatcmpl-abc123","object": "chat.completion.chunk","created": 1700000000,"model": "fountain-1.0","choices":[{"index": 0,"delta":{},"finish_reason": "stop"}]}

data: [DONE]

Chunk-Aufbau

Jeder Chunk enthält ein delta-Objekt mit dem neuen Textfragment.

Einzelner Chunk

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion.chunk",
  "created": 1700000000,
  "model": "fountain-1.0",
  "choices": [
    {
      "index": 0,
      "delta": {
        "content": "Hello"
      },
      "finish_reason": null
    }
  ]
}

•Der erste Chunk enthält die Rolle (assistant).
•Folgende Chunks enthalten nur den Content-Delta.
•Der letzte Chunk hat finish_reason: stop.

Stream verarbeiten

Lies den Stream Zeile für Zeile und parse jede data:-Zeile als JSON.

1curl -X POST https://app.anymize.ai/api/v1/llm/chat/completions \
2  -H "Authorization: Bearer YOUR_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "fountain-1.0",
6    "messages": [
7      {"role": "user", "content": "Write a short poem about the sea."}
8    ],
9    "stream": true
10  }'

Erster Chunk

Der erste Chunk enthält typischerweise die Rolle und ein leeres Content-Delta.

Rollen-Chunk

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion.chunk",
  "created": 1700000000,
  "model": "fountain-1.0",
  "choices": [
    {
      "index": 0,
      "delta": {
        "role": "assistant",
        "content": ""
      },
      "finish_reason": null
    }
  ]
}

Token-Info beim Streaming

Der letzte Chunk enthält die usage-Informationen mit der Gesamt-Token-Zahl.

Structured Outputs

Übersicht

Erzwinge strukturierte JSON-Ausgaben vom Modell — ideal für Datenextraktion und APIs.

JSON-Modus

Setze response_format auf json_object, um valides JSON zu erzwingen.

POST/api/v1/llm/chat/completions

1curl -X POST https://app.anymize.ai/api/v1/llm/chat/completions \
2  -H "Authorization: Bearer YOUR_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "fountain-1.0",
6    "messages": [
7      {"role": "system", "content": "You extract contact info. Respond in JSON with keys: name, email, phone."},
8      {"role": "user", "content": "My name is Anna Schmidt, email anna@example.com, phone +49 170 1234567."}
9    ],
10    "response_format": {"type": "json_object"}
11  }'

200Beispiel-Antwort im JSON-Modus

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "model": "fountain-1.0",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "{\"name\": \"Anna Schmidt\", \"email\": \"anna@example.com\", \"phone\": \"+49 170 1234567\"}"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 42,
    "completion_tokens": 28,
    "total_tokens": 70
  }
}

JSON Schema

Definiere ein exaktes Schema für die Ausgabe — das Modell hält sich strikt daran.

1curl -X POST https://app.anymize.ai/api/v1/llm/chat/completions \
2  -H "Authorization: Bearer YOUR_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "fountain-1.0",
6    "messages": [
7      {"role": "user", "content": "List three European capitals with their countries and population."}
8    ],
9    "response_format": {
10      "type": "json_schema",
11      "json_schema": {
12        "name": "capitals",
13        "schema": {
14          "type": "object",
15          "properties": {
16            "capitals": {
17              "type": "array",
18              "items": {
19                "type": "object",
20                "properties": {
21                  "city": {"type": "string"},
22                  "country": {"type": "string"},
23                  "population": {"type": "number"}
24                },
25                "required": ["city", "country", "population"]
26              }
27            }
28          },
29          "required": ["capitals"]
30        }
31      }
32    }
33  }'

Best Practices

Prompt-Tipp

Beschreibe im System-Prompt das gewünschte Format — das verbessert die Zuverlässigkeit.

•Verwende klare Feldnamen, die die erwarteten Werte beschreiben.
•Füge Beispiele in den System-Prompt ein, wenn das Schema komplex ist.
•Teste dein Schema mit verschiedenen Inputs, bevor du es in Produktion nutzt.

Function Calling

Was ist Function Calling?

Mit Function Calling kann das Modell deine definierten Tools aufrufen. Statt nur Text zu generieren, erkennt das Modell, wann ein externes Tool hilfreich ist, und gibt dir die Parameter zurück. Du führst die Funktion lokal aus und schickst das Ergebnis zurück.

Der Ablauf in vier Schritten:

1Du definierst Tools mit JSON Schema (z.B. web_search, get_weather)

2Das Modell analysiert die Nachricht und entscheidet, ein Tool aufzurufen

3Du führst die Funktion aus (API-Call, DB-Abfrage, etc.)

4Du schickst das Ergebnis zurück - das Modell generiert die finale Antwort

Anwendungsfälle

Web-Suche (Brave, Google, etc.)

Datenbank-Abfragen und CRM-Systeme

E-Mail und Messaging

Externe APIs (Wetter, Kalender, Maps, etc.)

Tool Definition

Tools werden als JSON Schema definiert. Das Modell nutzt die Beschreibungen, um zu entscheiden, wann es welches Tool aufruft.

Tool Schema

{
  "type": "function",
  "function": {
    "name": "web_search",
    "description": "Search the web for current information",
    "parameters": {
      "type": "object",
      "properties": {
        "query": {
          "type": "string",
          "description": "The search query"
        }
      },
      "required": [
        "query"
      ]
    }
  }
}

Beispiel: Web-Suche mit Brave

Ein vollständiges Beispiel: Das Modell erkennt, dass aktuelle Informationen benötigt werden, ruft die Brave Search API auf, und fasst die Ergebnisse zusammen.

Brave Search Integration

1import OpenAI from "openai"
2
3const client = new OpenAI({
4  apiKey: "YOUR_API_KEY",
5  baseURL: "https://app.anymize.ai/api/v1/llm",
6})
7
8const BRAVE_API_KEY = process.env.BRAVE_API_KEY
9
10// Step 1: Define the tool
11const tools = [
12  {
13    type: "function" as const,
14    function: {
15      name: "web_search",
16      description: "Search the web for current information. Use this when the user asks about recent events, news, or anything that requires up-to-date data.",
17      parameters: {
18        type: "object",
19        properties: {
20          query: { type: "string", description: "Search query" },
21        },
22        required: ["query"],
23      },
24    },
25  },
26]
27
28// Step 2: Send message with tools
29const response = await client.chat.completions.create({
30  model: "fountain-1.0",
31  messages: [
32    { role: "user", content: "What are the latest AI news today?" },
33  ],
34  tools,
35  tool_choice: "auto",
36})
37
38const message = response.choices[0].message
39
40// Step 3: Check if the model wants to call a tool
41if (message.tool_calls && message.tool_calls.length > 0) {
42  const toolCall = message.tool_calls[0]
43  const args = JSON.parse(toolCall.function.arguments)
44
45  // Step 4: Execute the Brave Search API
46  const searchResponse = await fetch(
47    `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(args.query)}&count=5`,
48    { headers: { "X-Subscription-Token": BRAVE_API_KEY } },
49  )
50  const searchData = await searchResponse.json()
51
52  // Format results for the model
53  const results = searchData.web?.results
54    ?.map((r: any) => `${r.title}: ${r.description}`)
55    .join("\n") || "No results found"
56
57  // Step 5: Send the search results back to the model
58  const finalResponse = await client.chat.completions.create({
59    model: "fountain-1.0",
60    messages: [
61      { role: "user", content: "What are the latest AI news today?" },
62      message,
63      {
64        role: "tool",
65        tool_call_id: toolCall.id,
66        content: results,
67      },
68    ],
69  })
70
71  console.log(finalResponse.choices[0].message.content)
72}

Tool Call Response

Wenn das Modell ein Tool aufrufen möchte, enthält die Antwort tool_calls statt Content. Der finish_reason ist dann 'tool_calls'.

200Tool Call Response

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "model": "fountain-1.0",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "web_search",
              "arguments": "{\"query\": \"latest AI news today\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ]
}

finish_reason beachten

Prüf immer den finish_reason: 'tool_calls' bedeutet, das Modell möchte ein Tool aufrufen. 'stop' bedeutet, die Antwort ist fertig.

Mehrere Tools gleichzeitig

Du kannst mehrere Tools definieren. Das Modell wählt automatisch das passende basierend auf der Nachricht.

Multi-Tool Setup

1const tools = [
2  {
3    type: "function",
4    function: {
5      name: "web_search",
6      description: "Search the web for current information",
7      parameters: {
8        type: "object",
9        properties: {
10          query: { type: "string" },
11        },
12        required: ["query"],
13      },
14    },
15  },
16  {
17    type: "function",
18    function: {
19      name: "get_weather",
20      description: "Get current weather for a location",
21      parameters: {
22        type: "object",
23        properties: {
24          location: { type: "string" },
25        },
26        required: ["location"],
27      },
28    },
29  },
30  {
31    type: "function",
32    function: {
33      name: "send_email",
34      description: "Send an email to a recipient",
35      parameters: {
36        type: "object",
37        properties: {
38          to: { type: "string", description: "Email address" },
39          subject: { type: "string" },
40          body: { type: "string" },
41        },
42        required: ["to", "subject", "body"],
43      },
44    },
45  },
46]
47
48// The model picks the right tool based on the user's message
49const response = await client.chat.completions.create({
50  model: "fountain-1.0",
51  messages: [
52    { role: "user", content: "Search for the latest Next.js release" },
53  ],
54  tools,
55  tool_choice: "auto",
56})

Tool Choice

Mit tool_choice steuerst du, ob und wie das Modell Tools nutzt.

Parameter	Type	Default	Description
`"auto"`	`string`	-	Modell entscheidet selbst (Standard)
`"none"`	`string`	-	Kein Tool wird aufgerufen
`"required"`	`string`	-	Modell muss ein Tool aufrufen
`{"type": "function", ...}`	`object`	-	Erzwingt den Aufruf einer bestimmten Funktion

MCP und Tool-Plattformen

Function Calling ist die Basis für das Model Context Protocol (MCP) und ähnliche Tool-Plattformen. Du kannst MCP-Server als Function-Calling-Tools integrieren, indem du die Tool-Definitionen des MCP-Servers als tools-Parameter übergibst.

MCP-kompatibel

anymize unterstützt das Standard-OpenAI-Tool-Format. Jedes MCP-Tool lässt sich als function definition abbilden und über unsere API nutzen.

Reasoning

Übersicht

Reasoning-Modelle zeigen ihren Denkprozess — ideal für komplexe Logik und mehrstufige Probleme.

Unterstützte Modelle

Verschiedene Modelle bieten Reasoning auf unterschiedliche Weise an.

Nativwaterfall-1.0Modelle mit eingebautem Chain-of-Thought wie o1 und o3.

Reasoning-Parameter

Steuere den Reasoning-Aufwand über den reasoning_effort-Parameter.

POST/api/v1/llm/chat/completions

Parameter	Type	Default	Description
`reasoning.effort`required	`string`	-	Bestimmt, wie viel das Modell nachdenkt, bevor es antwortet.

"low"Schnelle Antwort mit minimalem Nachdenken.

"medium"Ausgewogener Modus — gut für die meisten Aufgaben.

"high"Maximales Nachdenken für komplexe Probleme.

Beispiel-Request

Request an ein Reasoning-Modell mit mittlerem Aufwand.

1curl -X POST https://app.anymize.ai/api/v1/llm/chat/completions \
2  -H "Authorization: Bearer YOUR_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "waterfall-1.0",
6    "messages": [
7      {"role": "user", "content": "A farmer has 17 sheep. All but 9 run away. How many sheep does he have left?"}
8    ],
9    "reasoning": {
10      "effort": "high"
11    }
12  }'

Antwort mit Reasoning

Die Antwort enthält den sichtbaren Denkprozess und die finale Antwort.

200OK

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "model": "waterfall-1.0",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The farmer has 9 sheep left. The phrase \"all but 9\" means every sheep except 9 ran away."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 32,
    "completion_tokens": 45,
    "total_tokens": 77,
    "reasoning_tokens": 128
  }
}

Token-Verbrauch

Hinweis zum Token-Verbrauch

Reasoning-Modelle verbrauchen mehr Tokens — beachte Folgendes:

•Reasoning-Tokens werden separat gezählt und berechnet.
•Höherer reasoning_effort = mehr Tokens = höhere Kosten.
•Nutze Low-Effort für einfache Aufgaben, um Kosten zu sparen.

Wann Reasoning nutzen?

Empfehlung

Nutze Reasoning für Mathe, Code-Analyse, strategische Planung und mehrstufige Logik. Für einfache Fragen reichen Standard-Modelle.

Responses API

Endpunkt

Vereinfachtes API-Format für schnelle Integrationen — inspiriert vom Responses-Format.

POST/api/v1/llm/responses

Kompatibilität

Die Responses API bietet ein alternatives Format, das in manchen SDKs einfacher zu nutzen ist.

Parameter

Parameter	Type	Default	Description
`model`required	`string`	-	Modell-ID wie bei Chat Completions.
`input`required	`string \| array`	-	Eingabe als String oder Array von Nachrichten.
`instructions`	`string`	-	System-Instruktionen als String (ersetzt die system-Rolle).
`temperature`	`number`	`1`	Kreativität der Antwort (0–2).
`max_output_tokens`	`integer`	-	Maximale Token-Anzahl in der Antwort.
`top_p`	`number`	`1`	Nucleus-Sampling-Parameter.

Input-Formate

Du kannst die Eingabe als einfachen String oder als Nachrichten-Array senden.

Beispiel mit String-Input

{
  "model": "fountain-1.0",
  "input": "What is the capital of France?"
}

Beispiel mit Array-Input

{
  "model": "fountain-1.0",
  "input": [
    {
      "role": "user",
      "content": "What is the capital of France?"
    }
  ],
  "instructions": "You are a helpful geography assistant."
}

Beispiel-Request

1curl -X POST https://app.anymize.ai/api/v1/llm/responses \
2  -H "Authorization: Bearer YOUR_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "fountain-1.0",
6    "input": "Explain quantum computing in one sentence.",
7    "instructions": "You are a helpful science assistant."
8  }'

Antwort

Die Antwort folgt dem Responses-Format mit output_text als Hauptfeld.

200OK

{
  "id": "resp-abc123",
  "object": "response",
  "created_at": 1700000000,
  "model": "fountain-1.0",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "Quantum computing uses quantum-mechanical phenomena like superposition and entanglement to process information in ways that classical computers cannot."
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 24,
    "output_tokens": 28,
    "total_tokens": 52
  }
}

Unterschiede zur Chat API

Vergleich zwischen Chat Completions und Responses API.

Feature	Chat API	Responses API
Endpunkt	`/chat/completions`	`/responses`
Eingabe	`messages`	`input`
System-Prompt	`system role message`	`instructions`
Antwort-Objekt	`chat.completion`	`response`
Antwort-Text	`choices[0].message.content`	`output[0].content[0].text`
Token-Verbrauch	`prompt_tokens / completion_tokens`	`input_tokens / output_tokens`

Anonymer Chat

Endpunkt

Kombiniere Chat und Anonymisierung in einem einzigen Request — deine Daten werden vor dem Modell maskiert.

POST/api/v1/llm-anonymous/chat/completions

Basis-URL für anonymen Chathttps://app.anymize.ai/api/v1/llm-anonymous

Ablauf

So verarbeitet der anonyme Chat deine Anfrage:

1Deine Nachricht wird empfangen und analysiert.

2Personenbezogene Daten werden automatisch maskiert.

3Der anonymisierte Text wird an das Modell gesendet.

4Die Antwort wird de-anonymisiert und zurückgegeben.

Erhöhte Latenz

Durch die automatische Anonymisierung vor dem LLM-Aufruf und die De-Anonymisierung der Antwort entsteht eine höhere Latenz im Vergleich zum normalen Chat-Endpoint. Plane ca. 2-5 Sekunden zusätzliche Verarbeitungszeit ein.

Parameter

Gleiche Parameter wie Chat Completions plus Anonymisierungs-Optionen.

Parameter	Type	Default	Description
`model`required	`string`	-	Modell-ID — alle Chat-Modelle werden unterstützt.
`messages`required	`array`	-	Array von Nachrichten (system, user, assistant).
`language`	`string`	`"de"`	Sprache des Textes für bessere PII-Erkennung.
`stream`	`boolean`	`false`	SSE-Streaming aktivieren.

Platzhalter-Handling

Beim anonymen Chat werden personenbezogene Daten automatisch durch Platzhalter im Format [[Typ-HASH]] ersetzt. Damit die De-Anonymisierung funktioniert, muss das Modell diese Platzhalter exakt beibehalten.

Falsch

Sehr geehrter [Name anonymisiert], ich schreibe Ihnen wegen...

Richtig

Sehr geehrter Herr [[Person-ABC123]], ich schreibe Ihnen wegen...

Ohne den richtigen System-Prompt schreibt das Modell oft 'eine anonymisierte Person' oder '[Name anonymisiert]' statt den Platzhalter [[Person-ABC123]] zu verwenden. Das macht die De-Anonymisierung unmöglich.

Der anonyme Endpoint fügt automatisch folgenden Teil zum System-Prompt hinzu. Dieser wird an deinen eigenen System-Prompt angehängt, nicht ersetzt:

Automatisch injizierter System-Prompt-Teil

1## CRITICAL RULE: ANONYMIZATION PLACEHOLDERS
2
3THIS IS THE MOST IMPORTANT RULE. VIOLATING IT MAKES YOUR RESPONSE USELESS.
4
5The user's messages contain anonymized placeholders shaped [[<Type>-<HASH>]],
6where <Type> is the PII category (person, email, iban, telephone_number,
7address, ...) and <HASH> is a short random code.
8
9FORBIDDEN:
10- Writing "[Name anonymisiert]" or "[anonymized]"
11- Describing WHAT the placeholder is instead of USING it
12- Writing a double-bracket token that was NOT in the user's message — the hash
13  is a database key, so an invented one resolves to nothing. Never copy a hash
14  out of these instructions.
15
16REQUIRED:
17- Copy each placeholder character-for-character from the user's message
18- Use it inline like the real value: "Herr <placeholder> hat..."
19- Need a value the user never gave you? Use SINGLE brackets ([Name]).
20
21WHY: After your response, placeholders get replaced with real values.
22BEFORE RESPONDING: Check that every double-bracket token also appears, character-for-character, in the user's message.

Automatisch injiziert

Dieser Text wird als Ergänzung an deinen System-Prompt angehängt. Dein eigener System-Prompt bleibt vollständig erhalten. Du musst diesen Teil nicht selbst hinzufügen.

Beispiel-Request

1curl -X POST https://app.anymize.ai/api/v1/llm-anonymous/chat/completions \
2  -H "Authorization: Bearer YOUR_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "fountain-1.0",
6    "messages": [
7      {"role": "user", "content": "Schreibe eine E-Mail an Max Mustermann, max@example.com, wegen dem Termin am 15. Januar."}
8    ],
9    "language": "de",
10  }'

Antwort

Die Antwort enthält den de-anonymisierten Text und Metadaten.

200OK

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "model": "fountain-1.0",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Sehr geehrter Herr Max Mustermann,\n\nich schreibe Ihnen bezüglich unseres Termins am 15. Januar..."
      },
      "finish_reason": "stop"
    }
  ],
  "_anymize": {
    "anonymized": true,
    "job_id": "44444444-4444-4444-8444-444444444444",
    "language": "de"
  }
}

Response-Header

Der Header x-anonymization-job-id enthält die Job-ID für spätere Zuordnung.

Zero Data Retention

Zero Data Retention (ZDR) wird in deinen Account-Einstellungen konfiguriert, nicht pro API-Request. Wenn ZDR aktiv ist, werden keine Jobs oder Hash-Paare gespeichert. De-Anonymisierung ist dann nicht verfügbar.

Credit-Verbrauch

Anonymer Chat verbraucht Credits für zwei Leistungen:

•LLM-Credits für die Modellnutzung (wie beim normalen Chat).
•Anonymisierungs-Credits für die PII-Maskierung.

Modelle

Modelle auflisten

Rufe alle verfügbaren Modelle und ihre Metadaten ab.

GET/api/v1/llm/models

Beispiel-Request

1curl https://app.anymize.ai/api/v1/llm/models \
2  -H "Authorization: Bearer YOUR_API_KEY"

Beispiel-Antwort

Die Antwort enthält ein Array aller Modelle mit ID, Anbieter und Fähigkeiten.

200OK

{
  "object": "list",
  "data": [
    {
      "id": "fountain-1.0",
      "object": "model",
      "owned_by": "anymize"
    },
    {
      "id": "claude-sonnet-4-5-20250514",
      "object": "model",
      "owned_by": "anthropic"
    },
    {
      "id": "gpt-5",
      "object": "model",
      "owned_by": "openai"
    },
    {
      "id": "gemini-2.5-flash",
      "object": "model",
      "owned_by": "google"
    }
  ]
}

Einzelnes Modell abrufen

Rufe Details zu einem bestimmten Modell ab.

GET/api/v1/llm/models/{id}

Beispiel-Request

1curl https://app.anymize.ai/api/v1/llm/models/fountain-1.0 \
2  -H "Authorization: Bearer YOUR_API_KEY"

Beispiel-Antwort

200OK

{
  "id": "fountain-1.0",
  "object": "model",
  "owned_by": "anymize"
}

Anbieter

Modelle sind nach Anbieter gruppiert — hier eine Übersicht.

Anbieter	Modelle
Anthropic	Claude 4.5 Haiku, Claude Sonnet 4.6, Claude Opus 4.6
OpenAI	GPT-5, GPT-5 Mini
Google	Gemini 2.5 Flash, Gemini 3.0 Flash, Gemini 3.1 Pro
Mistral	Mistral Medium 3
Perplexity	Perplexity Pro
anymize	fountain-1.0, waterfall-1.0

Preise

Token-Preise variieren je nach Modell und Richtung.

Modell	Input / 1M Tokens	Output / 1M Tokens
`fountain-1.0`	1.00 EUR	5.00 EUR
`waterfall-1.0`	2.60 EUR	13.00 EUR
`Claude Haiku 4.5`	1.60 EUR	8.00 EUR
`Claude Sonnet 4.6`	4.20 EUR	21.00 EUR
`Claude Sonnet 5`	3.60 EUR	18.00 EUR
`Claude Opus 4.8`	6.95 EUR	34.70 EUR
`Claude Fable 5`	14.00 EUR	70.00 EUR
`GPT-5.5`	6.30 EUR	37.80 EUR
`GPT-5 Mini`	0.32 EUR	2.55 EUR
`GPT-5.6 Sol`	6.50 EUR	39.00 EUR
`GPT-5.6 Terra`	3.25 EUR	19.50 EUR
`GPT-5.6 Luna`	1.30 EUR	7.80 EUR
`Gemini 2.5 Pro`	1.58 EUR	12.60 EUR
`Gemini 3.5 Flash`	1.90 EUR	11.35 EUR
`Gemini 3.1 Pro`	5.00 EUR	25.00 EUR
`Mistral Medium 3`	1.80 EUR	9.00 EUR
`GLM 5.2`	1.77 EUR	5.55 EUR
`Perplexity Sonar Reasoning Pro`	5.00 EUR	25.00 EUR

Preishinweis

Die Preise können sich ändern. Aktuelle Preise findest du immer in deinem Dashboard.

Integration

Base URL

Ersetze einfach die Base URL in deinem bestehenden Setup. Alles andere bleibt gleich.

Standardhttps://app.anymize.ai/api/v1/llm

Anonymhttps://app.anymize.ai/api/v1/llm-anonymous

Anthropic / Claude Codehttps://app.anymize.ai/api

OpenAI SDK

Nutze das offizielle OpenAI SDK mit anymize als Base URL.

1import OpenAI from "openai"
2
3const client = new OpenAI({
4  apiKey: "YOUR_API_KEY",
5  baseURL: "https://app.anymize.ai/api/v1/llm",
6})
7
8const response = await client.chat.completions.create({
9  model: "fountain-1.0",
10  messages: [{ role: "user", content: "Hello!" }],
11})

Universell kompatibel

OpenAI-Clients auf /api/v1/llm, Anthropic-Clients auf /api. Ein Key, eine Pipeline.

Claude Code

ANTHROPIC_BASE_URL auf https://app.anymize.ai/api, Auth über ANTHROPIC_AUTH_TOKEN. Nicht ANTHROPIC_API_KEY: der sendet x-api-key und scheitert an Custom Gateways. Modell-IDs wie in der Console, z. B. anthropic/claude-sonnet-4.6.

AUTH_TOKEN, nicht API_KEY

Custom Base URL plus ANTHROPIC_API_KEY ergibt oft Invalid API key / Not logged in. Immer ANTHROPIC_AUTH_TOKEN, API_KEY unset.

1$env:ANTHROPIC_BASE_URL = "https://app.anymize.ai/api"
2$env:ANTHROPIC_AUTH_TOKEN = "YOUR_API_KEY"
3Remove-Item Env:ANTHROPIC_API_KEY -ErrorAction SilentlyContinue
4$env:ANTHROPIC_MODEL = "anthropic/claude-sonnet-4.6"
5$env:ANTHROPIC_SMALL_FAST_MODEL = "anthropic/claude-haiku-4.5"
6claude

ANTHROPIC_MODEL für die Hauptschleife, ANTHROPIC_SMALL_FAST_MODEL für Nebenaufgaben (Haiku spart Credits). IDs exakt wie in der Console.

Cursor

OpenAI-kompatibel. Override der OpenAI Base URL, anymize Key als OpenAI API Key, Modell-ID wie in der Console.

1. Cursor Settings, Abschnitt Models.

2. Override OpenAI Base URL: https://app.anymize.ai/api/v1/llm

3. OpenAI API Key = dein anymize Key. Danach eine Console-ID wählen, z. B. openai/gpt-5.4 oder anthropic/claude-sonnet-4.6.

Open WebUI

Unter Connections den OpenAI-Provider auf https://app.anymize.ai/api/v1/llm zeigen, API Key = anymize Key. Modelle kommen über GET /models.

1OPENAI_API_BASE_URL=https://app.anymize.ai/api/v1/llm
2OPENAI_API_KEY=YOUR_API_KEY

Dify

Model Provider OpenAI-API-kompatibel, API Base https://app.anymize.ai/api/v1/llm, Key = anymize Key. Danach die Console-ID als Modellname.

Cline / Roo Code

Provider OpenAI Compatible, Base URL https://app.anymize.ai/api/v1/llm, API Key der anymize Key. Danach dieselben Modell-IDs wie in der Console.

1{
2  "cline.apiProvider": "openai-compatible",
3  "cline.openAiBaseUrl": "https://app.anymize.ai/api/v1/llm",
4  "cline.openAiApiKey": "YOUR_API_KEY",
5  "cline.openAiModelId": "fountain-1.0"
6}

Continue.dev

In .continue/config.yaml ein OpenAI-Model mit apiBase https://app.anymize.ai/api/v1/llm und apiKey. model ist die volle anymize ID.

1models:
2  - name: anymize
3    provider: openai
4    model: fountain-1.0
5    apiBase: https://app.anymize.ai/api/v1/llm
6    apiKey: YOUR_API_KEY

LangChain / LangGraph

ChatOpenAI mit base_url auf .../api/v1/llm (ohne /chat/completions, LangChain hängt den Pfad selbst an). ChatAnthropic mit anthropic_api_url auf .../api.

1from langchain_openai import ChatOpenAI
2
3llm = ChatOpenAI(
4    model="fountain-1.0",
5    api_key="YOUR_API_KEY",
6    base_url="https://app.anymize.ai/api/v1/llm",
7)

LiteLLM

LiteLLM nimmt anymize als OpenAI-kompatibles Upstream (api_base .../api/v1/llm) und exponiert nach vorne OpenAI oder Anthropic. Nützlich, wenn ein Tool nur eines der beiden Protokolle spricht.

1model_list:
2  - model_name: anymize-claude
3    litellm_params:
4      model: openai/anthropic/claude-haiku-4.5
5      api_base: https://app.anymize.ai/api/v1/llm
6      api_key: os.environ/ANYMIZE_API_KEY

n8n Integration

Verwende anymize direkt in deinen n8n-Workflows. Setze die Base URL im OpenAI Chat Node oder HTTP Request Node.

n8n OpenAI Chat Node with anymize Base URL

Beispiel: OpenAI Chat Node in n8n mit anymize Base URL

1. Offne den OpenAI Chat Node in n8n und setze die Base URL auf https://app.anymize.ai/api/v1/llm

2. Trage deinen anymize API-Key als Bearer Token ein

3. Wahle ein Modell (z.B. fountain-1.0) und starte deinen Workflow