API DocsChat API

Chat API

OpenAI-kompatible Chat Completions API mit 20+ Modellen, Streaming, Structured Outputs, Function Calling und mehr.

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 #86efac">"Authorization: Bearer YOUR_API_KEY" \
3  -H #86efac">"Content-Type: application/json" \
4  -d '{
5    #86efac">"model": "fountain-1.0",
6    #86efac">"messages": [
7      {#86efac">"role": "system", "content": "You are a helpful assistant."},
8      {#86efac">"role": "user", "content": "Explain quantum computing in one sentence."}
9    ],
10    #86efac">"temperature": 0.7,
11    #86efac">"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. Fuge dazu den folgenden System-Prompt hinzu.

Ohne Prompt

Sehr geehrter [Name anonymisiert], bezuglich Ihres Anliegens...

Mit Prompt

Sehr geehrter Herr [[Person-ABC123]], bezuglich Ihres Anliegens...

Ohne explizite Anweisung ersetzt das Modell die Platzhalter durch generische Beschreibungen wie '[anonymisiert]'. Das zerstort die Zuordnung fur die De-Anonymisierung.

Wenn du voranonymisierte Texte verarbeitest, fuge diesen Teil zu deinem System-Prompt hinzu:

System-Prompt fur 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 in format [[Type-HASH]]:
9- [[Person-QSEZB6]] = a person's name
10- [[email-BE2966]] = an email address
11- [[iban-5B7BCF]] = a bank account
12- [[telephone_number-F29732]] = a phone number
13
14FORBIDDEN:
15- Writing "[Name anonymisiert]" or "[anonymized]"
16- Describing WHAT the placeholder is instead of USING it
17
18REQUIRED:
19- Copy [[Person-QSEZB6]] exactly as-is
20- Write "Herr [[Person-QSEZB6]] hat..." (use it like a real name)
21
22WHY: After your response, placeholders get replaced with real values.`,
23    },
24    {
25      role: "user",
26      content: "Schreibe eine E-Mail an [[Person-ABC123]] bezuglich dem Vertrag.",
27    },
28  ],
29})
30
31// Model responds: "Sehr geehrter Herr [[Person-ABC123]], ..."
32// 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 hinzufugen.

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 #86efac">"Authorization: Bearer YOUR_API_KEY" \
3  -H #86efac">"Content-Type: application/json" \
4  -d '{
5    #86efac">"model": "fountain-1.0",
6    #86efac">"messages": [
7      {#86efac">"role": "user", "content": "Write a short poem about the sea."}
8    ],
9    #86efac">"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 #86efac">"Authorization: Bearer YOUR_API_KEY" \
3  -H #86efac">"Content-Type: application/json" \
4  -d '{
5    #86efac">"model": "fountain-1.0",
6    #86efac">"messages": [
7      {#86efac">"role": "system", "content": "You extract contact info. Respond in JSON with keys: name, email, phone."},
8      {#86efac">"role": "user", "content": "My name is Anna Schmidt, email anna@example.com, phone +49 170 1234567."}
9    ],
10    #86efac">"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 #86efac">"Authorization: Bearer YOUR_API_KEY" \
3  -H #86efac">"Content-Type: application/json" \
4  -d '{
5    #86efac">"model": "fountain-1.0",
6    #86efac">"messages": [
7      {#86efac">"role": "user", "content": "List three European capitals with their countries and population."}
8    ],
9    #86efac">"response_format": {
10      #86efac">"type": "json_schema",
11      #86efac">"json_schema": {
12        #86efac">"name": "capitals",
13        #86efac">"schema": {
14          #86efac">"type": "object",
15          #86efac">"properties": {
16            #86efac">"capitals": {
17              #86efac">"type": "array",
18              #86efac">"items": {
19                #86efac">"type": "object",
20                #86efac">"properties": {
21                  #86efac">"city": {"type": "string"},
22                  #86efac">"country": {"type": "string"},
23                  #86efac">"population": {"type": "number"}
24                },
25                #86efac">"required": ["city", "country", "population"]
26              }
27            }
28          },
29          #86efac">"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 zuruck. Du fuhrst die Funktion lokal aus und schickst das Ergebnis zuruck.

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 fuhrst die Funktion aus (API-Call, DB-Abfrage, etc.)

4Du schickst das Ergebnis zuruck - das Modell generiert die finale Antwort

Anwendungsfalle

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 vollstandiges Beispiel: Das Modell erkennt, dass aktuelle Informationen benotigt 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 mochte, enthalt 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

Pruf immer den finish_reason: 'tool_calls' bedeutet, das Modell mochte ein Tool aufrufen. 'stop' bedeutet, die Antwort ist fertig.

Mehrere Tools gleichzeitig

Du kannst mehrere Tools definieren. Das Modell wahlt 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 fur das Model Context Protocol (MCP) und ahnliche Tool-Plattformen. Du kannst MCP-Server als Function-Calling-Tools integrieren, indem du die Tool-Definitionen des MCP-Servers als tools-Parameter ubergibst.

MCP-kompatibel

anymize unterstutzt das Standard-OpenAI-Tool-Format. Jedes MCP-Tool lasst sich als function definition abbilden und uber 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 #86efac">"Authorization: Bearer YOUR_API_KEY" \
3  -H #86efac">"Content-Type: application/json" \
4  -d '{
5    #86efac">"model": "waterfall-1.0",
6    #86efac">"messages": [
7      {#86efac">"role": "user", "content": "A farmer has 17 sheep. All but 9 run away. How many sheep does he have left?"}
8    ],
9    #86efac">"reasoning": {
10      #86efac">"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 #86efac">"Authorization: Bearer YOUR_API_KEY" \
3  -H #86efac">"Content-Type: application/json" \
4  -d '{
5    #86efac">"model": "fountain-1.0",
6    #86efac">"input": "Explain quantum computing in one sentence.",
7    #86efac">"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 unmoglich.

Der anonyme Endpoint fugt automatisch folgenden Teil zum System-Prompt hinzu. Dieser wird an deinen eigenen System-Prompt angehangt, 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 in format [[Type-HASH]]:
6- [[Person-QSEZB6]] = a person's name
7- [[email-BE2966]] = an email address
8- [[iban-5B7BCF]] = a bank account
9- [[telephone_number-F29732]] = a phone number
10- [[Adress-NT9DQE]] = an address
11
12FORBIDDEN:
13- Writing "[Name anonymisiert]" or "[anonymized]"
14- Describing WHAT the placeholder is instead of USING it
15- Inventing NEW [[Type-HASH]] placeholders
16
17REQUIRED:
18- Copy [[Person-QSEZB6]] exactly as-is
19- Write "Herr [[Person-QSEZB6]] hat..." (use it like a real name)
20
21WHY: After your response, placeholders get replaced with real values.
22BEFORE RESPONDING: Check that every [[Placeholder-HASH]] appears exactly as written.

Automatisch injiziert

Dieser Text wird als Erganzung an deinen System-Prompt angehangt. Dein eigener System-Prompt bleibt vollstandig erhalten. Du musst diesen Teil nicht selbst hinzufugen.

Beispiel-Request

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

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 #86efac">"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 #86efac">"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
Moonshot	Kimi K2.5
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`	0.15 EUR	0.60 EUR
`waterfall-1.0`	0.60 EUR	3.00 EUR
`Claude 4.5 Haiku`	1.00 EUR	5.00 EUR
`Claude Sonnet 4.6`	3.00 EUR	15.00 EUR
`Claude Opus 4.6`	5.00 EUR	25.00 EUR
`GPT-5`	1.50 EUR	10.00 EUR
`GPT-5 Mini`	0.30 EUR	2.00 EUR
`Gemini 2.5 Flash`	0.15 EUR	0.60 EUR
`Gemini 3.0 Flash`	0.30 EUR	2.50 EUR
`Gemini 3.1 Pro`	2.00 EUR	12.00 EUR
`Mistral Medium 3`	0.80 EUR	2.50 EUR
`Perplexity Pro`	3.00 EUR	15.00 EUR
`Kimi K2.5`	0.60 EUR	3.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

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

Jeder OpenAI-kompatible Client funktioniert mit anymize. Einfach die Base URL andern.

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