API DocsChat API

Chat API

OpenAI-compatible Chat Completions API with 20+ models, streaming, structured outputs, function calling and more.

Endpoint

Send chat messages and receive an AI-generated response.

POST/api/v1/llm/chat/completions

SDK compatibility

This endpoint is fully compatible with the OpenAI chat format — you can use existing SDKs.

Parameters

Parameter	Type	Default	Description
`model`required	`string`	-	Model ID, e.g. gpt-4o or claude-sonnet-4-20250514.
`messages`required	`array`	-	Array of messages with role and content.
`stream`	`boolean`	`false`	If true, the response is streamed via SSE.
`temperature`	`number`	`1`	Response creativity (0–2). Lower values = more focused.
`max_tokens`	`integer`	-	Maximum number of tokens in the response.
`top_p`	`number`	`1`	Nucleus sampling — alternative to temperature.
`response_format`	`object`	-	Forces a specific output format (e.g. JSON).
`tools`	`array`	-	List of tools/functions the model can call.
`tool_choice`	`string`	-	Controls whether and which tools are called.
`frequency_penalty`	`number`	`0`	Penalizes frequently used tokens (-2 to 2).
`presence_penalty`	`number`	`0`	Penalizes already used tokens (-2 to 2).
`stop`	`string \| array`	-	Sequences at which generation stops.

Message format

Each message has a role (system, user, assistant) and content.

Message example

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

Basic request

Minimal request with a single user message.

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  }'

Response

The response contains the generated message, model info, and token usage.

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 usage

Every response includes prompt_tokens, completion_tokens, and total_tokens.

Handling Anonymized Placeholders

When sending pre-anonymized text to the standard chat endpoint, the model must preserve [[Type-HASH]] placeholders exactly. Add the following system prompt to your messages.

Without prompt

Dear [name redacted], regarding your request...

With prompt

Dear Mr. [[Person-ABC123]], regarding your request...

Without explicit instructions, the model replaces placeholders with generic descriptions like '[redacted]'. This breaks the mapping for de-anonymization.

When processing pre-anonymized text, add this part to your system prompt:

System prompt for placeholders

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, ..."

Or use the anonymous endpoint

The anonymous endpoint (/api/v1/llm-anonymous) injects this system prompt automatically. You don't need to add it yourself there.

Streaming

Enable streaming

Set stream: true in the request to receive responses in real time.

POST/api/v1/llm/chat/completions

"stream": true

SSE format

Responses arrive as Server-Sent Events — one chunk per line with a data: prefix.

Example 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 structure

Each chunk contains a delta object with the new text fragment.

Single chunk

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

•The first chunk contains the role (assistant).
•Subsequent chunks contain only the content delta.
•The last chunk has finish_reason: stop.

Consuming the stream

Read the stream line by line and parse each data: line as 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  }'

First chunk

The first chunk typically contains the role and an empty content delta.

Role 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 during streaming

The last chunk contains usage information with the total token count.

Structured Outputs

Overview

Force structured JSON outputs from the model — ideal for data extraction and APIs.

JSON mode

Set response_format to json_object to enforce valid JSON output.

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  }'

200Example response in JSON mode

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

Define an exact schema for the output — the model will follow it strictly.

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 tip

Describe the desired format in your system prompt — this improves reliability.

•Use clear field names that describe the expected values.
•Include examples in the system prompt if the schema is complex.
•Test your schema with different inputs before using it in production.

Function Calling

What is Function Calling?

Function Calling lets the model call your defined tools. Instead of just generating text, the model recognizes when an external tool would be helpful and returns the parameters. You execute the function locally and send the result back.

The flow in four steps:

1You define tools with JSON Schema (e.g. web_search, get_weather)

2The model analyzes the message and decides to call a tool

3You execute the function (API call, DB query, etc.)

4You send the result back - the model generates the final answer

Use Cases

Web search (Brave, Google, etc.)

Database queries and CRM systems

Email and messaging

External APIs (weather, calendar, maps, etc.)

Tool Definition

Tools are defined as JSON Schema. The model uses the descriptions to decide when to call which tool.

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

Example: Web Search with Brave

A complete example: The model recognizes that current information is needed, calls the Brave Search API, and summarizes the results.

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

When the model wants to call a tool, the response contains tool_calls instead of content. The finish_reason is '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"
    }
  ]
}

Check finish_reason

Always check the finish_reason: 'tool_calls' means the model wants to call a tool. 'stop' means the response is complete.

Multiple Tools

You can define multiple tools. The model automatically picks the right one based on the message.

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

Use tool_choice to control if and how the model uses tools.

Parameter	Type	Default	Description
`"auto"`	`string`	-	Model decides on its own (default)
`"none"`	`string`	-	No tool will be called
`"required"`	`string`	-	Model must call a tool
`{"type": "function", ...}`	`object`	-	Force a specific function call

MCP and Tool Platforms

Function Calling is the foundation for the Model Context Protocol (MCP) and similar tool platforms. You can integrate MCP servers as function calling tools by passing the MCP server's tool definitions as the tools parameter.

MCP compatible

anymize supports the standard OpenAI tool format. Any MCP tool can be mapped as a function definition and used through our API.

Reasoning

Overview

Reasoning models show their thought process — ideal for complex logic and multi-step problems.

Supported models

Different models offer reasoning in different ways.

Nativewaterfall-1.0Models with built-in chain-of-thought like o1 and o3.

Reasoning parameters

Control reasoning effort via the reasoning_effort parameter.

POST/api/v1/llm/chat/completions

Parameter	Type	Default	Description
`reasoning.effort`required	`string`	-	Determines how much the model thinks before responding.

"low"Quick response with minimal thinking.

"medium"Balanced mode — good for most tasks.

"high"Maximum thinking for complex problems.

Example request

Request to a reasoning model with medium effort.

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  }'

Response with reasoning

The response contains the visible thought process and the final answer.

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 usage

Token usage note

Reasoning models consume more tokens — keep the following in mind:

•Reasoning tokens are counted and billed separately.
•Higher reasoning_effort = more tokens = higher cost.
•Use low effort for simple tasks to save costs.

When to use reasoning

Recommendation

Use reasoning for math, code analysis, strategic planning, and multi-step logic. Standard models are fine for simple questions.

Responses API

Endpoint

Simplified API format for quick integrations — inspired by the Responses format.

POST/api/v1/llm/responses

Compatibility

The Responses API offers an alternative format that is simpler to use in some SDKs.

Parameters

Parameter	Type	Default	Description
`model`required	`string`	-	Model ID, same as Chat Completions.
`input`required	`string \| array`	-	Input as a string or array of messages.
`instructions`	`string`	-	System instructions as a string (replaces the system role).
`temperature`	`number`	`1`	Response creativity (0–2).
`max_output_tokens`	`integer`	-	Maximum number of tokens in the response.
`top_p`	`number`	`1`	Nucleus sampling parameter.

Input formats

You can send input as a simple string or as a message array.

Example with string input

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

Example with array input

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

Example 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  }'

Response

The response follows the Responses format with output_text as the main field.

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

Differences from Chat API

Comparison between Chat Completions and Responses API.

Feature	Chat API	Responses API
Endpoint	`/chat/completions`	`/responses`
Input	`messages`	`input`
System prompt	`system role message`	`instructions`
Response object	`chat.completion`	`response`
Response text	`choices[0].message.content`	`output[0].content[0].text`
Token usage	`prompt_tokens / completion_tokens`	`input_tokens / output_tokens`

Anonymous Chat

Endpoint

Combine chat and anonymization in a single request — your data is masked before reaching the model.

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

Base URL for anonymous chathttps://app.anymize.ai/api/v1/llm-anonymous

Flow

Here's how anonymous chat processes your request:

1Your message is received and analyzed.

2Personal data is automatically masked.

3The anonymized text is sent to the model.

4The response is de-anonymized and returned to you.

Higher Latency

Due to automatic anonymization before the LLM call and de-anonymization of the response, there is higher latency compared to the standard chat endpoint. Expect roughly 2-5 seconds of additional processing time.

Parameters

Same parameters as Chat Completions plus anonymization options.

Parameter	Type	Default	Description
`model`required	`string`	-	Model ID — all chat models are supported.
`messages`required	`array`	-	Array of messages (system, user, assistant).
`language`	`string`	`"de"`	Text language for better PII detection.
`stream`	`boolean`	`false`	Enable SSE streaming.

Placeholder Handling

In anonymous chat, personal data is automatically replaced with placeholders in the format [[Type-HASH]]. For de-anonymization to work, the model must preserve these placeholders exactly.

Wrong

Dear [name redacted], I am writing to you regarding...

Correct

Dear Mr. [[Person-ABC123]], I am writing to you regarding...

Without the right system prompt, the model often writes 'an anonymized person' or '[name redacted]' instead of using the placeholder [[Person-ABC123]]. This makes de-anonymization impossible.

The anonymous endpoint automatically appends the following part to your system prompt. It is added to your own system prompt, not replacing it:

Auto-injected system prompt part

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.

Automatically injected

This text is appended to your system prompt as an addition. Your own system prompt is fully preserved. You don't need to add this part yourself.

Example 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  }'

Response

The response contains the de-anonymized text and metadata.

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

The x-anonymization-job-id header contains the job ID for later reference.

Zero Data Retention

Zero Data Retention (ZDR) is configured in your account settings, not per API request. When ZDR is enabled, no jobs or hash pairs are stored. De-anonymization is not available.

Credit usage

Anonymous chat consumes credits for two services:

•LLM credits for model usage (same as regular chat).
•Anonymization credits for PII masking.

Models

List models

Retrieve all available models and their metadata.

GET/api/v1/llm/models

Example request

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

Example response

The response contains an array of all models with ID, provider, and capabilities.

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

Get a single model

Retrieve details for a specific model.

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

Example request

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

Example response

200OK

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

Providers

Models are grouped by provider — here's an overview.

Provider	Models
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

Pricing

Token pricing varies by model and direction.

Model	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

Pricing note

Prices are subject to change. You can always find current pricing in your dashboard.

Integration

Base URL

Just replace the base URL in your existing setup. Everything else stays the same.

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

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

OpenAI SDK

Use the official OpenAI SDK with anymize as 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})

Universal compatibility

Any OpenAI-compatible client works with anymize. Just change the base URL.

n8n Integration

Use anymize directly in your n8n workflows. Set the base URL in the OpenAI Chat node or HTTP Request node.

n8n OpenAI Chat Node with anymize Base URL

Example: OpenAI Chat node in n8n with anymize base URL

1. Open the OpenAI Chat node in n8n and set the base URL to https://app.anymize.ai/api/v1/llm

2. Enter your anymize API key as Bearer token

3. Select a model (e.g. fountain-1.0) and start your workflow