Anthropic‑Format
POST /v1/messages nimmt eine Anfrage im Anthropic-Messages-Format entgegen und antwortet im selben Format, gestreamt oder nicht. Verwenden Sie es mit dem Anthropic SDK und mit darauf aufbauenden Tools wie Claude Code: Setzen Sie die Base-URL, verwenden Sie Ihren Shannon-API-Key und nennen Sie eine Shannon-Modell-ID.
POST https://api.shannon-ai.com/v1/messages
Richten Sie das Anthropic SDK auf die Shannon-Base-URL. Das SDK hängt /v1/messages an und sendet Ihren Key im Header x-api-key.
import anthropic
client = anthropic.Anthropic(
api_key="YOUR_API_KEY",
base_url="https://api.shannon-ai.com",
)
message = client.messages.create(
model="shannon-3",
max_tokens=1024,
messages=[{"role": "user", "content": "Say hello in one sentence."}],
)
for block in message.content:
if block.type == "text":
print(block.text) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const message = await client.messages.create({
model: "shannon-3",
max_tokens: 1024,
messages: [{ role: "user", content: "Say hello in one sentence." }],
});
for (const block of message.content) {
if (block.type === "text") console.log(block.text);
} curl https://api.shannon-ai.com/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "content-type: application/json" \
-d '{
"model": "shannon-3",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Say hello in one sentence."}]
}' Die Antwort ist eine Nachricht, deren content eine Liste von Blöcken ist. Finden Sie die Blöcke anhand ihres type: Hat das Modell nachgedacht, ist der erste Block thinking, und der Text folgt danach.
{
"id": "msg_5f0c1e7a9b3d4c62a8e1f07d2b46c9a3",
"type": "message",
"role": "assistant",
"model": "shannon-3",
"content": [
{
"type": "thinking",
"thinking": "The user wants a greeting in one sentence. Keep it short and friendly."
},
{
"type": "text",
"text": "Hello, it is good to meet you."
}
],
"stop_reason": "end_turn",
"usage": {
"input_tokens": 1184,
"output_tokens": 46
}
} Header
| Header | Wert | Beschreibung |
|---|---|---|
x-api-key | YOUR_API_KEY | Ihr API-Key. Stattdessen wird Authorization: Bearer YOUR_API_KEY akzeptiert. |
content-type | application/json | Erforderlich. |
anthropic-version | 2023-06-01 | Wird akzeptiert, ist nicht erforderlich. Das Anthropic SDK sendet 2023-06-01; die Antwort hat unabhängig vom Wert dasselbe Format. |
anthropic-beta | Wird akzeptiert, ist nicht erforderlich. | |
x-request-id | Optional. Ihre eigene ID für die Anfrage. Sie kommt unverändert in der Antwort zurück; ohne sie enthält die Antwort eine ID aus 12 hexadezimalen Zeichen. |
Anfragefelder
Nur messages ist erforderlich. Die Spalte Angewendet von nennt die Modelle, bei denen ein Feld die Antwort verändert. Die gehosteten Open-Weight-Modelle sind die zwölf IDs der Modellliste; die Shannon-3-Familie besteht aus shannon-3, shannon-3-pro, shannon-3.1 und shannon-3.1-pro. Modelle & Preise
| Feld | Typ | Standard | Beschreibung | Angewendet von |
|---|---|---|---|---|
model | string | shannon-1.6-lite | Eine Shannon-Modell-ID aus der Modellliste. Senden Sie sie mit jeder Anfrage. Die Zuordnung unterscheidet nicht zwischen Groß- und Kleinschreibung. Jeder andere Name gibt 400 unknown model zurück; ein Tool, das eigene Modellnamen sendet, muss daher auf eine Shannon-ID eingestellt werden. | Alle Modelle |
messages | array | Erforderlich. Die Konversation, älteste Nachricht zuerst, mit den Rollen user und assistant. Siehe Nachrichten und Content-Blöcke weiter unten. | Alle Modelle | |
system | string | array | Anweisungen für das Modell: ein String oder ein Array von Textblöcken. Siehe System-Prompt weiter unten. | Gehostete Open-Weight-Modelle, shannon-1.6-*, shannon-2-*, shannon-coder-1 | |
max_tokens | integer | 4096 | Obergrenze der Antwort, in Tokens. Bei diesem Endpunkt optional; das Anthropic SDK sendet es immer. Ein Wert außerhalb von 1 bis 65,536 wird in diesen Bereich verschoben. Es ist auch der Betrag, der von Ihrem Guthaben zurückgelegt wird, solange die Anfrage läuft. | Gehostete Open-Weight-Modelle, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1 |
stream | boolean | false | true sendet die Antwort als Server-Sent Events. Siehe Streaming weiter unten. | Alle Modelle |
temperature | number | Sampling-Temperatur. Bei den gehosteten Open-Weight-Modellen werden Werte zwischen 0 und 2 gehalten. | Gehostete Open-Weight-Modelle, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1 | |
top_p | number | Nucleus-Sampling. | Gehostete Open-Weight-Modelle | |
stop_sequences | array | Bis zu 4 Strings. Die Antwort endet vor dem ersten, der darin vorkommt. stop_reason bleibt end_turn. | Gehostete Open-Weight-Modelle | |
tools | array | Die Tools, die das Modell aufrufen darf, jeweils als {"name", "description", "input_schema"}. Siehe Tools weiter unten. | Alle Modelle | |
tool_choice | object | {"type": "auto"} lässt das Modell entscheiden, {"type": "any"} zwingt es, ein Tool aufzurufen, {"type": "tool", "name": "…"} zwingt es, dieses Tool aufzurufen. | Gehostete Open-Weight-Modelle | |
thinking | object | Wie viel das Modell nachdenkt, bevor es antwortet. Siehe Thinking weiter unten. | Gehostete Open-Weight-Modelle | |
web_search | boolean | false | Eine Shannon-Erweiterung des Formats: true lässt das Modell das Web durchsuchen, bevor es antwortet. | shannon-1.6-*, shannon-2-*, Shannon-3-Familie |
Ohne max_tokens beträgt der Wert 4,096, bei shannon-coder-1 65,536.
metadata, top_k, service_tier und cache_control-Markierungen an Blöcken werden akzeptiert, damit vorhandener Client-Code unverändert läuft. Sie verändern die Antwort nicht; Prompt-Caching bei den gehosteten Open-Weight-Modellen erfolgt automatisch.
Eine JSON-Antwort nach einem Schema fordern Sie bei Chat Completions mit response_format und bei Responses mit text.format an. Strukturierte Ausgaben
Eine Anfrage mit System-Prompt und Thinking
Diese Anfrage sendet einen System-Prompt, ein Thinking-Budget, eine Temperatur und eine Stop-Sequenz. Sie verwendet ein gehostetes Open-Weight-Modell, das alle davon anwendet.
import anthropic
client = anthropic.Anthropic(
api_key="YOUR_API_KEY",
base_url="https://api.shannon-ai.com",
)
message = client.messages.create(
model="DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
max_tokens=4096,
system="You are a physics teacher. Answer in two sentences.",
thinking={"type": "enabled", "budget_tokens": 2048},
temperature=0.3,
stop_sequences=["\n\n"],
messages=[{"role": "user", "content": "Why is the sky blue?"}],
)
for block in message.content:
if block.type == "thinking":
print("reasoning:", block.thinking)
elif block.type == "text":
print("answer:", block.text)
print(message.usage) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const message = await client.messages.create({
model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
max_tokens: 4096,
system: "You are a physics teacher. Answer in two sentences.",
thinking: { type: "enabled", budget_tokens: 2048 },
temperature: 0.3,
stop_sequences: ["\n\n"],
messages: [{ role: "user", content: "Why is the sky blue?" }],
});
for (const block of message.content) {
if (block.type === "thinking") console.log("reasoning:", block.thinking);
if (block.type === "text") console.log("answer:", block.text);
}
console.log(message.usage); curl https://api.shannon-ai.com/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "content-type: application/json" \
-d '{
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"max_tokens": 4096,
"system": "You are a physics teacher. Answer in two sentences.",
"thinking": {"type": "enabled", "budget_tokens": 2048},
"temperature": 0.3,
"stop_sequences": ["\n\n"],
"messages": [{"role": "user", "content": "Why is the sky blue?"}]
}' Bei den gehosteten Open-Weight-Modellen meldet usage die aus dem Prompt-Cache gelesenen Tokens getrennt von den übrigen Input-Tokens.
{
"usage": {
"input_tokens": 31,
"cache_read_input_tokens": 0,
"cache_creation_input_tokens": 0,
"output_tokens": 62
}
} System-Prompt
system ist ein String oder ein Array von Textblöcken in der Form [{"type": "text", "text": "…"}]. Die Texte der Blöcke werden mit einem Zeilenumbruch verbunden.
Er wird von den gehosteten Open-Weight-Modellen, shannon-1.6-lite, shannon-1.6-pro, shannon-2-lite, shannon-2-pro und shannon-coder-1 angewendet. Bei einer ID der Shannon-3-Familie gehören Anweisungen, die gelten müssen, in die User-Nachricht.
Nachrichten und Content-Blöcke
Eine Nachricht hat eine role, user oder assistant, und einen content. content ist ein String oder ein Array von Blöcken.
| Block | Beschreibung | Verfügbar bei |
|---|---|---|
{"type": "text", "text": "…"} | Text. | Alle Modelle |
{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": "…"}}{"type": "image", "source": {"type": "url", "url": "…"}} | Ein Bild in einer user-Nachricht, als Base64 oder per URL. | Shannon-3-Familie, shannon-1.6-lite, shannon-1.6-pro und die gehosteten Open-Weight-Modelle, die Bild-Input aufführen |
{"type": "document", "source": {"type": "base64", "media_type": "application/pdf", "data": "…"}} | Ein Dokument (PDF, Word, PowerPoint oder Excel) in einer user-Nachricht, als Base64 oder per URL. | Shannon-3-Familie |
{"type": "tool_use", "id": "toolu_…", "name": "…", "input": {…}} | In einer assistant-Nachricht: ein Tool-Aufruf, den das Modell in einer früheren Antwort gemacht hat. | Alle Modelle |
{"type": "tool_result", "tool_use_id": "toolu_…", "content": "…"} | In einer user-Nachricht: das Ergebnis dieses Aufrufs. content ist ein String oder eine Liste von Textblöcken. | Alle Modelle |
Sie können den content einer früheren Antwort unverändert zurücksenden: text- und tool_use-Blöcke werden gelesen, thinking-Blöcke übersprungen.
Bei den Shannon-Stufen werden Bilder und Dokumente aus der letzten user-Nachricht gelesen. Größen und Limits haben eine eigene Seite. Bilder und Dateien
Thinking
Die gehosteten Open-Weight-Modelle bilden thinking auf einen Reasoning-Aufwand ab. Ohne das Feld ist der Aufwand hoch.
| Form | budget_tokens | Wirkung |
|---|---|---|
{"type": "disabled"} | Kein Reasoning. Die Antwort hat keinen thinking-Block. | |
{"type": "enabled", "budget_tokens": 2048} | ≤ 2,048 | Niedriger Aufwand. |
{"type": "enabled", "budget_tokens": 8192} | ≤ 8,192 | Mittlerer Aufwand. |
{"type": "enabled", "budget_tokens": 16000} | > 8,192 | Hoher Aufwand. |
Ein Modell, das nachdenkt, liefert sein Reasoning als Block {"type": "thinking", "thinking": "…"} vor dem Text. Auch die Shannon-Stufen, die nachdenken, senden es.
Die Aufwandsstufen sind auf einer eigenen Seite beschrieben. Reasoning-Aufwand
Tools
Ein Tool ist eine Funktion, die Ihr Code ausführt. Beschreiben Sie jedes mit einem name, einer description und einem input_schema. Wenn das Modell ein Tool braucht, enthält die Antwort einen tool_use-Block, und stop_reason ist tool_use.
Eine Tool-Definition in tools:
[
{
"name": "get_weather",
"description": "Current weather for a city.",
"input_schema": {
"type": "object",
"properties": {
"city": {
"type": "string"
}
},
"required": [
"city"
]
}
}
] Der content einer Antwort, die es aufruft:
[
{
"type": "text",
"text": ""
},
{
"type": "tool_use",
"id": "toolu_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
"name": "get_weather",
"input": {
"city": "Paris"
}
}
] Führen Sie das Tool aus und senden Sie die Anfrage dann erneut, mit dem Aufruf und einem tool_result-Block, die zu messages hinzugefügt wurden:
[
{
"role": "user",
"content": "What is the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "tool_use",
"id": "toolu_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
"name": "get_weather",
"input": {
"city": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_3d9a7c1e5b2f4a60c8e1d7f09b24a6c5",
"content": "{\"temperature_c\": 18, \"sky\": \"cloudy\"}"
}
]
}
] tool_choice
| Form | Wirkung | Angewendet von |
|---|---|---|
{"type": "auto"} | Das Modell entscheidet, ob es ein Tool aufruft. Dies ist der Standard. | Alle Modelle |
{"type": "any"} | Das Modell muss eines der Tools aufrufen. | Gehostete Open-Weight-Modelle |
{"type": "tool", "name": "…"} | Das Modell muss das genannte Tool aufrufen. | Gehostete Open-Weight-Modelle |
Nur Tools mit einem input_schema werden gelesen. Die Websuche ist bei diesem Endpunkt kein Tool: Setzen Sie das Feld web_search.
Die Tool-Schleife ist auf einer eigenen Seite vollständig beschrieben. Funktionsaufrufe
Die Antwort
| Feld | Typ | Beschreibung | Gesendet von |
|---|---|---|---|
id | string | msg_ gefolgt von 32 hexadezimalen Zeichen. | Alle Modelle |
type | string | Immer message. | Alle Modelle |
role | string | Immer assistant. | Alle Modelle |
model | string | Die kanonische ID des Modells, das geantwortet hat. | Alle Modelle |
content | array | Die Blöcke der Antwort, in dieser Reihenfolge: thinking, wenn das Modell nachgedacht hat, text, dann ein tool_use pro Tool-Aufruf. | Alle Modelle |
stop_reason | string | Warum die Antwort endete. Siehe die Werte unten. | Alle Modelle |
usage | object | input_tokens und output_tokens. | Alle Modelle |
sources | array | Nur bei einer Anfrage mit web_search: true, deren Suche etwas gefunden hat: die Ergebnisse, die dem Modell gegeben wurden, jeweils mit index, title und url. [1] in der Antwort ist der Eintrag mit index 1. In einem Stream kommt es mit dem Event message_delta. | shannon-1.6-*, shannon-2-*, Shannon-3-Familie |
usage.cache_read_input_tokens | integer | cache_read_input_tokens ist der Teil des Prompts, der aus dem Cache gelesen wurde; input_tokens ist der Rest. cache_creation_input_tokens ist immer 0. | Gehostete Open-Weight-Modelle |
Antwortblöcke
| Block | Beschreibung |
|---|---|
{"type": "thinking", "thinking": "…"} | Das Reasoning des Modells. Es gibt kein Feld signature. |
{"type": "text", "text": "…"} | Der Antworttext. Er kann leer sein, wenn die Antwort ein Tool-Aufruf ist. |
{"type": "tool_use", "id": "toolu_…", "name": "…", "input": {…}} | Ein Tool-Aufruf. input ist ein JSON-Objekt. Senden Sie das Ergebnis mit derselben id zurück. |
stop_reason
| stop_reason | Beschreibung | Gesendet von |
|---|---|---|
end_turn | Das Modell hat seine Antwort beendet, oder eine Ihrer stop_sequences ist aufgetreten. | Alle Modelle |
tool_use | Die Antwort enthält einen oder mehrere Tool-Aufrufe. | Alle Modelle |
max_tokens | Die Antwort wurde am Output-Limit abgeschnitten. | Shannon-3-Familie, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1, in Streams |
Streaming
Setzen Sie stream auf true, um Server-Sent Events zu erhalten. Jeder Frame hat eine event:-Zeile mit dem Namen des Events und eine data:-Zeile mit einem JSON-Objekt, das den Namen in type wiederholt. Die Stream-Helfer des Anthropic SDK lesen diese Events für Sie:
import anthropic
client = anthropic.Anthropic(
api_key="YOUR_API_KEY",
base_url="https://api.shannon-ai.com",
)
with client.messages.stream(
model="shannon-3",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain server-sent events in three sentences."}],
) as stream:
for text in stream.text_stream:
print(text, end="", flush=True)
message = stream.get_final_message()
print()
print(message.stop_reason, message.usage) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const stream = client.messages.stream({
model: "shannon-3",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain server-sent events in three sentences." }],
});
stream.on("text", (text) => process.stdout.write(text));
const message = await stream.finalMessage();
console.log("\n", message.stop_reason, message.usage); curl -N https://api.shannon-ai.com/v1/messages \
-H "x-api-key: YOUR_API_KEY" \
-H "content-type: application/json" \
-d '{
"model": "shannon-3",
"max_tokens": 1024,
"stream": true,
"messages": [{"role": "user", "content": "Explain server-sent events in three sentences."}]
}' Die Events in der Reihenfolge, in der sie eintreffen:
| Event | Daten | Wann |
|---|---|---|
message_start | message | Immer zuerst. message enthält die ID, die Rolle, das Modell, einen leeren content und eine usage, die bei null beginnt. |
content_block_start | index, content_block | Ein Block wird geöffnet. content_block ist ein leerer text- oder thinking-Block oder ein tool_use-Block mit seiner id und seinem name. |
content_block_delta | index, delta {"type": "thinking_delta", "thinking"} | Ein Stück des Reasonings, für einen thinking-Block. |
content_block_delta | index, delta {"type": "text_delta", "text"} | Ein Stück der Antwort, für einen text-Block. |
content_block_delta | index, delta {"type": "input_json_delta", "partial_json"} | Die Argumente eines Tool-Aufrufs, vollständig in einem Delta, für einen tool_use-Block. |
content_block_stop | index | Der Block mit diesem index ist abgeschlossen. |
message_delta | delta {stop_reason, stop_sequence}, usage | Das Ende der Antwort: delta.stop_reason und die usage der Anfrage. |
message_stop | Immer zuletzt. |
Blöcke sind nach index in der Reihenfolge ihres Öffnens nummeriert, und ein Block ist abgeschlossen, bevor der nächste beginnt. Lesen Sie jeden Block nach seinem Typ, nicht nach seiner Nummer: Ein Stream kann zuerst einen leeren text-Block öffnen, dann den thinking-Block und die Antwort in einem späteren text-Block liefern.
event: message_start
data: {"type":"message_start","message":{"id":"msg_5f0c…","type":"message","role":"assistant","model":"shannon-3","content":[],"usage":{"input_tokens":0,"output_tokens":0}}}
event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
event: content_block_stop
data: {"type":"content_block_stop","index":0}
event: content_block_start
data: {"type":"content_block_start","index":1,"content_block":{"type":"thinking","thinking":""}}
event: content_block_delta
data: {"type":"content_block_delta","index":1,"delta":{"type":"thinking_delta","thinking":"Three sentences: what it is, how it is framed, why it is used."}}
event: ping
data: {"type": "ping"}
event: content_block_stop
data: {"type":"content_block_stop","index":1}
event: content_block_start
data: {"type":"content_block_start","index":2,"content_block":{"type":"text","text":""}}
event: content_block_delta
data: {"type":"content_block_delta","index":2,"delta":{"type":"text_delta","text":"Server-sent events let a server push text over one HTTP reply."}}
event: content_block_stop
data: {"type":"content_block_stop","index":2}
event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"input_tokens":1190,"output_tokens":84}}
event: message_stop
data: {"type":"message_stop"} Keep-alive
| Gesendet von | Beschreibung |
|---|---|
Shannon-3-Familie, shannon-1.6-lite, shannon-1.6-pro, shannon-coder-1 | Ein ping-Event mit den Daten {"type": "ping"}, alle 15 Sekunden. |
| Gehostete Open-Weight-Modelle | Eine Kommentarzeile : keepalive, alle 15 Sekunden, solange das Modell arbeitet. |
Ein Stream, der fehlschlägt
Ein Fehler nach dem Start des Streams ist ein error-Event mit demselben Body wie eine Fehlerantwort: {"type": "error", "error": {"type", "message"}}. Die abschließenden Events message_delta und message_stop folgen trotzdem. Behandeln Sie die Antwort als fehlgeschlagen und senden Sie die Anfrage erneut.
Fehler
Fehler verwenden den Anthropic-Fehler-Body: type ist error, und das Objekt error enthält einen type und eine message. Die Tabelle listet, was dieser Endpunkt am häufigsten zurückgibt. Die vollständige Liste, mit Hinweisen, was wiederholt werden sollte, hat eine eigene Seite. Fehlerbehandlung
{
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "unknown model: no-such-model"
}
} | Status | Typ | Nachricht | Wann |
|---|---|---|---|
401 | authentication_error | Missing authenticationInvalid API key | Es wurde kein API-Key gesendet, oder der Key ist unbekannt oder widerrufen. |
400 | invalid_request_error | unknown model: <id> | model ist keine Shannon-Modell-ID. |
400 | invalid_request_error | No user message provided | Shannon-Stufen: Die Anfrage enthält weder Nutzertext noch tools. |
400 | invalid_request_error | <id> does not accept image input | Ein Bild wurde an ein gehostetes Open-Weight-Modell ohne Bild-Input gesendet. |
422 | invalid_request_error | Failed to deserialize the JSON body into the target type: … | messages fehlt, oder ein Feld hat den falschen JSON-Typ. |
429 | rate_limit_error | Quota exceeded. Upgrade your plan at shannon-ai.com/plan | max_tokens ist größer als das, was von Ihrem Guthaben übrig ist. |
429 | rate_limit_error | Too many requests. Retry in <n>s. | Flood-Schutz: mehr als 120 Anfragen in einer Minute auf Ihrem Konto. |
429 | rate_limit_error | Shannon Coder call quota reached. Upgrade your plan at shannon-ai.com/plan | shannon-coder-1: Die Shannon-Coder-Aufrufe Ihres Plans für das aktuelle 4-Stunden-Fenster sind aufgebraucht. |
500 | server_error | The model backend failed to answer. Please retry. | Das Modell hat keine Antwort erzeugt. Senden Sie die Anfrage erneut. |
502 | api_error | The model backend failed to answer. Please retry. | Das Modell hat keine Antwort erzeugt. Senden Sie die Anfrage erneut. |
Token zählen
POST /v1/messages/count_tokens nimmt denselben Body wie eine Messages-Anfrage (model, system, messages, tools) und gibt {"input_tokens": n} zurück: die Anzahl der Input-Tokens, die der Anfrage berechnet würden. Es zählt für die gehosteten Open-Weight-Modelle, ist kostenlos und wird vom Flood-Schutz nicht mitgezählt.
import anthropic
client = anthropic.Anthropic(
api_key="YOUR_API_KEY",
base_url="https://api.shannon-ai.com",
)
count = client.messages.count_tokens(
model="DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
system="You are a physics teacher. Answer in two sentences.",
messages=[{"role": "user", "content": "Why is the sky blue?"}],
)
print(count.input_tokens) import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: "YOUR_API_KEY",
baseURL: "https://api.shannon-ai.com",
});
const count = await client.messages.countTokens({
model: "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
system: "You are a physics teacher. Answer in two sentences.",
messages: [{ role: "user", content: "Why is the sky blue?" }],
});
console.log(count.input_tokens); curl https://api.shannon-ai.com/v1/messages/count_tokens \
-H "x-api-key: YOUR_API_KEY" \
-H "content-type: application/json" \
-d '{
"model": "DeepSeek-V4-Flash-0731-W4A16-AUTOROUND-REAP",
"system": "You are a physics teacher. Answer in two sentences.",
"messages": [{"role": "user", "content": "Why is the sky blue?"}]
}'
# {"input_tokens": 31} Das Zählen hat eine eigene Seite, mit dem Klartext-Endpunkt und den Limits. Token zählen