{"meta":{"title":"Nutzungs- und Abrechnungsmetriken","intro":"In diesem Handbuch wird gezeigt, wie Tokenanzahl, Kontextfensterauslastung, KI-Kreditkosten und Kontokontingent aus einer Copilot SDK-Anwendung gelesen werden. Beispiele für TypeScript, Python, Go, .NET, Java und Rust.","product":"GitHub Copilot","breadcrumbs":[{"href":"/de/enterprise-cloud@latest/copilot","title":"GitHub Copilot"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos","title":"Vorgehensweisen"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk","title":"Copilot SDK"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features","title":"Funktionen"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/usage-and-billing","title":"Nutzung und Abrechnung"}],"documentType":"article"},"body":"# Nutzungs- und Abrechnungsmetriken\n\nIn diesem Handbuch wird gezeigt, wie Tokenanzahl, Kontextfensterauslastung, KI-Kreditkosten und Kontokontingent aus einer Copilot SDK-Anwendung gelesen werden. Beispiele für TypeScript, Python, Go, .NET, Java und Rust.\n\n\n\n\n\n> \\[!TIP]\n> Jedes Beispiel ist über die Sprachen hinweg funktional äquivalent. Der TypeScript-Codeausschnitt ist standardmäßig erweitert. Wählen Sie Ihre Sprache aus den reduzierbaren Blöcken aus, um die gleiche Logik in diesem SDK anzuzeigen.\n\n## Überblick\n\nDas SDK zeigt Nutzungsdaten über zwei ergänzende Mechanismen an:\n\n* **Sitzungsereignisse**: kurzlebige Ereignisse, die von der Laufzeit während der Ausführung eines Turns ausgegeben werden. Abonnieren Sie diese, um Echtzeitdaten pro API-Aufruf zu erhalten.\n* **RPC-Methoden**: Anforderungs-/Antwortaufrufe, die Sie bei Bedarf tätigen. Verwenden Sie diese, um eine Momentaufnahme kumulierter Gesamtwerte zu erstellen oder das Kontingent auf Kontoebene abzufragen.\n\nDie folgende Tabelle ordnet jedes Signal der API zu, die es verfügbar macht.\n\n| Signal | API | Geltungsbereich | Typ |\n| ------------------------------------------------ | ------------------------------ | --------------- | --- |\n| Anzahl der Token pro Anruf | | | |\n| `assistant.usage`-Ereignis | Session | Event | |\n| Auslastung des Kontextfensters | | | |\n| `session.usage_info`-Ereignis | Session | Event | |\n| Aufschlüsselung des Kontextfensters (bei Bedarf) | `session.metadata.contextInfo` | Session | RPC |\n| Kumulierte KI-Guthaben- und Token-Gesamtsummen | `session.usage.getMetrics` | Session | RPC |\n| Preisgestaltung für KI-Credits pro Modell | `models.list` | Server | RPC |\n| Kontokontingent- und Premiuminteraktionen | `account.getQuota` | Server | RPC |\n\n> \\[!NOTE]\n> `session.usage.getMetrics`, `session.metadata.contextInfo`und `session.metadata.recomputeContextTokens` sind in der generierten RPC-Oberfläche experimentell markiert. In .NET wird die experimentelle Diagnose `GHCP001` ausgegeben, die Sie mit `#pragma warning disable GHCP001` oder einer `GHCP001` auf Projektebene unterdrücken. Heften Sie sowohl das SDK als auch die Copilot-CLI-Laufzeitumgebung an, wenn Ihre Anwendung davon abhängt.\n\nIn den folgenden Feldtabellen sind nur die Felder aufgeführt, die in den Beispielen auf dieser Seite verwendet werden. Die vollständige, stets aktuelle Feldreferenz bilden die generierten SDK-Typen sowie [Ereignisse einer Streaming-Sitzung](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/streaming-events), das bei jedem Abhängigkeitsbump aus dem CLI-Schema neu generiert wird. Betrachten Sie diese als die maßgebliche Quelle und diese Seite als einen aufgabenorientierten Leitfaden.\n\n## Anzahl der Token pro Anruf\n\nDas `assistant.usage` Ereignis wird einmal für jeden Modell-API-Aufruf in einem Turn ausgegeben (einschließlich der von Unteragenten vorgenommenen Aufrufe). Es enthält die Tokenanzahl und den Abrechnungsmultiplikator für diesen einzelnen Anruf.\n\nIm folgenden Beispiel werden diese Felder verwendet. Siehe [Ereignisse einer Streaming-Sitzung](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/streaming-events#assistantusage) für die vollständige Liste, einschließlich Feldern für Cache, Schlussfolgerung, Latenz und Nachverfolgung.\n\n| Feld | Typ | Description |\n| -------------- | -------- | ------------------------------------------------------------------------- |\n| `model` | `string` | Modellkennung für diesen Aufruf |\n| `inputTokens` | `number` | Verbrauchte Eingabetoken |\n| `outputTokens` | `number` | Erzeugte Ausgabetoken |\n| `cost` | `number` | Premium-Anforderungsmultiplikator, der auf diesen Aufruf angewendet wurde |\n\n> \\[!TIP]\n> `assistant.usage` ist flüchtig, wird also live bereitgestellt, aber beim Fortsetzen einer Sitzung nicht erneut abgespielt. Um kumulierte Gesamtwerte nachträglich auszulesen, rufen Sie `session.usage.getMetrics` auf (siehe [Kumulierte KI-Gutschriften und Token-Gesamtwerte](#accumulated-ai-credit-and-token-totals)).\n\n
\n
TypeScript
\n\n```typescript\nsession.on(\"assistant.usage\", (event) => {\n const { model, inputTokens, outputTokens, cost } = event.data;\n console.log(\n `${model}: in=${inputTokens ?? 0} out=${outputTokens ?? 0} cost=${cost ?? 0}`,\n );\n});\n```\n\n
\n\n
Python
\n\n```python\ndef on_usage(event):\n if event.type == SessionEventType.ASSISTANT_USAGE:\n data = event.data\n print(f\"{data.model}: in={data.input_tokens or 0} out={data.output_tokens or 0} cost={data.cost or 0}\")\n\nsession.on(on_usage)\n```\n\n
\n\n
Go
\n\n```golang\nsession.On(func(event copilot.SessionEvent) {\n d, ok := event.Data.(*copilot.AssistantUsageData)\n if !ok {\n return\n }\n in, out, cost := int64(0), int64(0), float64(0)\n if d.InputTokens != nil {\n in = *d.InputTokens\n }\n if d.OutputTokens != nil {\n out = *d.OutputTokens\n }\n if d.Cost != nil {\n cost = *d.Cost\n }\n fmt.Printf(\"%s: in=%d out=%d cost=%g\\n\", d.Model, in, out, cost)\n})\n```\n\n
\n\n
.NET
\n\n```csharp\nsession.On(evt =>\n{\n var data = evt.Data;\n Console.WriteLine(\n $\"{data.Model}: in={data.InputTokens ?? 0} out={data.OutputTokens ?? 0} cost={data.Cost ?? 0}\");\n});\n```\n\n
\n\n
Java
\n\n\n\n```java\nsession.on(AssistantUsageEvent.class, event -> {\n var data = event.getData();\n long in = data.inputTokens() != null ? data.inputTokens() : 0;\n long out = data.outputTokens() != null ? data.outputTokens() : 0;\n double cost = data.cost() != null ? data.cost() : 0.0;\n System.out.printf(\"%s: in=%d out=%d cost=%s%n\", data.model(), in, out, cost);\n});\n```\n\n
\n\n
Rust
\n\n```rust\nuse github_copilot_sdk::session_events::AssistantUsageData;\n\nlet mut events = session.subscribe();\nwhile let Ok(event) = events.recv().await {\n if event.event_type == \"assistant.usage\" {\n if let Some(data) = event.typed_data::() {\n println!(\n \"{}: in={} out={} cost={}\",\n data.model,\n data.input_tokens.unwrap_or(0),\n data.output_tokens.unwrap_or(0),\n data.cost.unwrap_or(0.0),\n );\n }\n }\n}\n```\n\n
\n\n
\n\n## Auslastung des Kontextfensters\n\nDie Anzahl der Tokens zeigt Ihnen, wie viele Tokens jeder Aufruf verbraucht hat. Die Kontextfensternutzung teilt Ihnen mit, wie voll das Eingabeaufforderungsfenster des Modells momentan ist – nützlich für die Anzeige einer Statusleiste oder Warnung des Benutzers, bevor die automatische Komprimierung gestartet wird.\n\n### Echtzeit-Updates mit `session.usage_info`\n\nDie Laufzeit gibt ein `session.usage_info` Ereignis aus, wenn sich die Größe des Kontextfensters ändert. Das Beispiel verwendet `currentTokens` und `tokenLimit`; siehe [Ereignisse einer Streaming-Sitzung](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/streaming-events#sessionusage_info) für die vollständige Nutzlast.\n\n| Feld | Typ | Description |\n| --------------- | -------- | ------------------------------------------------- |\n| `currentTokens` | `number` | Token derzeit im Kontextfenster |\n| `tokenLimit` | `number` | Maximale Token für das Kontextfenster des Modells |\n\n
\n
TypeScript
\n\n```typescript\nsession.on(\"session.usage_info\", (event) => {\n const { currentTokens, tokenLimit } = event.data;\n const pct = Math.round((currentTokens / tokenLimit) * 100);\n console.log(`Context: ${currentTokens}/${tokenLimit} (${pct}%)`);\n});\n```\n\n
\n\n
Python
\n\n```python\ndef on_usage_info(event):\n if event.type == SessionEventType.SESSION_USAGE_INFO:\n data = event.data\n pct = round(data.current_tokens / data.token_limit * 100)\n print(f\"Context: {data.current_tokens}/{data.token_limit} ({pct}%)\")\n\nsession.on(on_usage_info)\n```\n\n
\n\n
Go
\n\n```golang\nsession.On(func(event copilot.SessionEvent) {\n d, ok := event.Data.(*copilot.SessionUsageInfoData)\n if !ok {\n return\n }\n pct := int(float64(d.CurrentTokens) / float64(d.TokenLimit) * 100)\n fmt.Printf(\"Context: %d/%d (%d%%)\\n\", d.CurrentTokens, d.TokenLimit, pct)\n})\n```\n\n
\n\n
.NET
\n\n```csharp\nsession.On(evt =>\n{\n var pct = (int)Math.Round((double)evt.Data.CurrentTokens / evt.Data.TokenLimit * 100);\n Console.WriteLine($\"Context: {evt.Data.CurrentTokens}/{evt.Data.TokenLimit} ({pct}%)\");\n});\n```\n\n
\n\n
Java
\n\n\n\n```java\nsession.on(SessionUsageInfoEvent.class, event -> {\n var data = event.getData();\n long pct = Math.round((double) data.currentTokens() / data.tokenLimit() * 100);\n System.out.printf(\"Context: %d/%d (%d%%)%n\", data.currentTokens(), data.tokenLimit(), pct);\n});\n```\n\n
\n\n
Rust
\n\n```rust\nuse github_copilot_sdk::session_events::SessionUsageInfoData;\n\nlet mut events = session.subscribe();\nwhile let Ok(event) = events.recv().await {\n if event.event_type == \"session.usage_info\" {\n if let Some(data) = event.typed_data::() {\n let pct = (data.current_tokens as f64 / data.token_limit as f64 * 100.0) as i64;\n println!(\"Context: {}/{} ({}%)\", data.current_tokens, data.token_limit, pct);\n }\n }\n}\n```\n\n
\n\n
\n\n### On-Demand-Aufschlüsselung mit `session.metadata.contextInfo`\n\nEreignisse werden nur ausgelöst, wenn sich der Kontext ändert. Um die aktuelle Aufschlüsselung jederzeit zu lesen , z. B. direkt nach dem Fortsetzen einer Sitzung – rufen Sie `session.metadata.contextInfo`auf. Übergeben Sie `promptTokenLimit` für `outputTokenLimit`, um den Standardwert der Laufzeit zu verwenden; übergeben Sie `0` für `0`, wenn der Wert unbekannt ist.\n\nDas Ergebnis `contextInfo` ist `null` so lange, bis die Sitzung initialisiert wurde (die Systemaufforderung und die Toolmetadaten wurden zwischengespeichert). Es unterteilt die Gesamtsumme in `systemTokens`, `toolDefinitionsTokens` und `promptTokenLimit` sowie den `conversationTokens`.\n\n
\n
TypeScript
\n\n```typescript\nconst { contextInfo } = await session.rpc.metadata.contextInfo({\n promptTokenLimit: 0,\n outputTokenLimit: 0,\n});\n\nif (contextInfo) {\n console.log(\n `Total ${contextInfo.totalTokens}/${contextInfo.promptTokenLimit} ` +\n `(system=${contextInfo.systemTokens}, conversation=${contextInfo.conversationTokens})`,\n );\n}\n```\n\n
\n\n
Python
\n\n```python\nresult = await session.rpc.metadata.context_info(\n MetadataContextInfoRequest(prompt_token_limit=0, output_token_limit=0)\n)\ninfo = result.context_info\n\nif info is not None:\n print(\n f\"Total {info.total_tokens}/{info.prompt_token_limit} \"\n f\"(system={info.system_tokens}, conversation={info.conversation_tokens})\"\n )\n```\n\n
\n\n
Go
\n\n```golang\nresult, _ := session.RPC.Metadata.ContextInfo(ctx, &rpc.MetadataContextInfoRequest{\n PromptTokenLimit: 0,\n OutputTokenLimit: 0,\n})\n\nif info := result.ContextInfo; info != nil {\n fmt.Printf(\"Total %d/%d (system=%d, conversation=%d)\\n\",\n info.TotalTokens, info.PromptTokenLimit, info.SystemTokens, info.ConversationTokens)\n}\n```\n\n
\n\n
.NET
\n\n```csharp\nvar result = await session.Rpc.Metadata.ContextInfoAsync(promptTokenLimit: 0, outputTokenLimit: 0);\nvar info = result.ContextInfo;\n\nif (info is not null)\n{\n Console.WriteLine(\n $\"Total {info.TotalTokens}/{info.PromptTokenLimit} \" +\n $\"(system={info.SystemTokens}, conversation={info.ConversationTokens})\");\n}\n```\n\n
\n\n
Java
\n\n\n\n```java\nvar result = session.getRpc().metadata\n .contextInfo(new SessionMetadataContextInfoParams(null, 0L, 0L, null))\n .join();\nvar info = result.contextInfo();\n\nif (info != null) {\n System.out.printf(\"Total %d/%d (system=%d, conversation=%d)%n\",\n info.totalTokens(), info.promptTokenLimit(), info.systemTokens(), info.conversationTokens());\n}\n```\n\n
\n\n
Rust
\n\n```rust\nuse github_copilot_sdk::rpc::MetadataContextInfoRequest;\n\nlet result = session\n .rpc()\n .metadata()\n .context_info(MetadataContextInfoRequest {\n prompt_token_limit: 0,\n output_token_limit: 0,\n selected_model: None,\n })\n .await?;\n\nif let Some(info) = result.context_info {\n println!(\n \"Total {}/{} (system={}, conversation={})\",\n info.total_tokens, info.prompt_token_limit, info.system_tokens, info.conversation_tokens,\n );\n}\n```\n\n
\n\n
\n\n## Kumulierte KI-Guthaben- und Token-Gesamtsummen\n\n`session.usage.getMetrics` gibt die laufenden Summen für die gesamte Sitzung in einem einzelnen Aufruf zurück. Dies ist die sauberste Möglichkeit, KI-Kreditkosten zu lesen, da sie jeden API-Aufruf (Haupt-Agent und Sub-Agents) für Sie aggregiert.\n\nIm Beispiel werden die folgenden Felder verwendet. Der generierte `UsageGetMetricsResult` Typ ist der vollständige Verweis.\n\n| Feld | Typ | Description |\n| ------------------------- | ----------------------------- | ------------------------------------------------------------------------------------------------------------- |\n| `totalNanoAiu` | `number` | Sitzungsweite KI-Kreditkosten in Nano-AI-Einheiten |\n| `totalPremiumRequestCost` | `number` | Premium-Anforderungskosten für alle Modelle, nach Multiplikatoren |\n| `modelMetrics` | `Record` | Modellbasierte Aufschlüsselung; jeder Eintrag hat `usage.inputTokens`, `usage.outputTokens`und `totalNanoAiu` |\n\n> \\[!NOTE]\n> Die Kosten werden in **Nano-AI-Einheiten** gemeldet (das Feld ist benannt `totalNanoAiu`). Die genaue Konvertierung in KI-Gutschriften und die genaue Bedeutung der Premium-Anforderungsabrechnung werden durch GitHub Copilot Abrechnung definiert, nicht durch das SDK– behandeln Sie [GitHub Copilot Abrechnungsdokumentation](/de/enterprise-cloud@latest/copilot/concepts/billing) als Wahrheitsquelle und überprüfen Sie vor dem Auftauchen währungsähnlicher Werte für Benutzer. Die Beispiele teilen der Einfachheit halber durch `1e9`, gemäß dem SI-Präfix `nano`. Vergewissern Sie sich, dass dies mit der aktuellen Abrechnung übereinstimmt, bevor Sie sich darauf verlassen. Die `modelMetrics`- und `tokenDetails`-Maps verwenden Laufzeitzeichenfolgen (Modell-IDs und Namen von Tokentypen) als Schlüssel, die vom SDK-Typsystem nicht validiert werden.\n\n
\n
TypeScript
\n\n```typescript\nconst metrics = await session.rpc.usage.getMetrics();\n\nconst aiCredits = (metrics.totalNanoAiu ?? 0) / 1e9;\nconsole.log(`AI credits used: ${aiCredits.toFixed(6)}`);\nconsole.log(`Premium requests: ${metrics.totalPremiumRequestCost}`);\n\nfor (const [model, m] of Object.entries(metrics.modelMetrics)) {\n if (!m) continue;\n console.log(\n `${model}: in=${m.usage.inputTokens} out=${m.usage.outputTokens} ` +\n `nanoAiu=${m.totalNanoAiu ?? 0}`,\n );\n}\n```\n\n
\n\n
Python
\n\n```python\nmetrics = await session.rpc.usage.get_metrics()\n\nai_credits = (metrics.total_nano_aiu or 0) / 1e9\nprint(f\"AI credits used: {ai_credits:.6f}\")\nprint(f\"Premium requests: {metrics.total_premium_request_cost}\")\n\nfor model, m in metrics.model_metrics.items():\n print(f\"{model}: in={m.usage.input_tokens} out={m.usage.output_tokens} nanoAiu={m.total_nano_aiu or 0}\")\n```\n\n
\n\n
Go
\n\n```golang\nmetrics, _ := session.RPC.Usage.GetMetrics(ctx)\n\naiCredits := float64(0)\nif metrics.TotalNanoAiu != nil {\n aiCredits = *metrics.TotalNanoAiu / 1e9\n}\nfmt.Printf(\"AI credits used: %.6f\\n\", aiCredits)\nfmt.Printf(\"Premium requests: %v\\n\", metrics.TotalPremiumRequestCost)\n\nfor model, m := range metrics.ModelMetrics {\n nanoAiu := float64(0)\n if m.TotalNanoAiu != nil {\n nanoAiu = *m.TotalNanoAiu\n }\n fmt.Printf(\"%s: in=%d out=%d nanoAiu=%v\\n\", model, m.Usage.InputTokens, m.Usage.OutputTokens, nanoAiu)\n}\n```\n\n
\n\n
.NET
\n\n```csharp\nvar metrics = await session.Rpc.Usage.GetMetricsAsync();\n\nvar aiCredits = (metrics.TotalNanoAiu ?? 0) / 1e9;\nConsole.WriteLine($\"AI credits used: {aiCredits:F6}\");\nConsole.WriteLine($\"Premium requests: {metrics.TotalPremiumRequestCost}\");\n\nforeach (var (model, m) in metrics.ModelMetrics)\n{\n Console.WriteLine(\n $\"{model}: in={m.Usage.InputTokens} out={m.Usage.OutputTokens} nanoAiu={m.TotalNanoAiu ?? 0}\");\n}\n```\n\n
\n\n
Java
\n\n\n\n```java\nvar metrics = session.getRpc().usage.getMetrics().join();\n\ndouble aiCredits = metrics.totalNanoAiu() != null ? metrics.totalNanoAiu() / 1e9 : 0;\nSystem.out.printf(\"AI credits used: %.6f%n\", aiCredits);\nSystem.out.printf(\"Premium requests: %s%n\", metrics.totalPremiumRequestCost());\n\nmetrics.modelMetrics().forEach((model, m) -> {\n double nanoAiu = m.totalNanoAiu() != null ? m.totalNanoAiu() : 0;\n System.out.printf(\"%s: in=%d out=%d nanoAiu=%s%n\",\n model, m.usage().inputTokens(), m.usage().outputTokens(), nanoAiu);\n});\n```\n\n
\n\n
Rust
\n\n```rust\nlet metrics = session.rpc().usage().get_metrics().await?;\n\nlet ai_credits = metrics.total_nano_aiu.unwrap_or(0.0) / 1e9;\nprintln!(\"AI credits used: {ai_credits:.6}\");\nprintln!(\"Premium requests: {}\", metrics.total_premium_request_cost);\n\nfor (model, m) in &metrics.model_metrics {\n let nano_aiu = m.total_nano_aiu.unwrap_or(0.0);\n println!(\n \"{model}: in={} out={} nanoAiu={nano_aiu}\",\n m.usage.input_tokens, m.usage.output_tokens,\n );\n}\n```\n\n
\n\n
\n\n## Preisgestaltung für KI-Credits pro Modell\n\nUm die Kosten zu schätzen, bevor Sie einen Turn ausführen, lesen Sie die Tokenpreise jedes Modells von `models.list`. Dies ist ein serverbezogener Aufruf auf dem Client, sodass keine Sitzung erforderlich ist. Die Preise werden in KI-Gutschriften pro Abrechnungsbatch von Token ausgedrückt. Der generierte `ModelBillingTokenPrices`-Typ listet jedes Feld auf, einschließlich `cachePrice`.\n\n| Feld | Typ | Description |\n| --------------------------------- | -------- | ------------------------------------------------------------------- |\n| `billing.multiplier` | `number` | Kostenmultiplikator für Premium-Anforderungen relativ zum Basissatz |\n| `billing.tokenPrices.inputPrice` | `number` | KI-Kreditkosten pro Batch von Eingabetoken |\n| `billing.tokenPrices.outputPrice` | `number` | KI-Kreditkosten pro Batch von Ausgabetoken |\n| `billing.tokenPrices.batchSize` | `number` | Anzahl der Token pro Abrechnungsbatch |\n\n> \\[!NOTE]\n> Preiswerte ändern sich, wenn Pläne und Modelle weiterentwickelt werden. Lesen Sie sie zur Laufzeit wie unten gezeigt; codieren Sie die Zahlen niemals fest in Ihre Anwendung.\n\n
\n
TypeScript
\n\n```typescript\nconst { models } = await client.rpc.models.list({});\n\nfor (const model of models) {\n const prices = model.billing?.tokenPrices;\n if (!prices) continue;\n console.log(\n `${model.id}: input=${prices.inputPrice} output=${prices.outputPrice} ` +\n `per ${prices.batchSize} tokens (x${model.billing?.multiplier ?? 1})`,\n );\n}\n```\n\n
\n\n
Python
\n\n```python\nresult = await client.rpc.models.list(ModelsListRequest())\n\nfor model in result.models:\n prices = model.billing.token_prices if model.billing else None\n if prices is None:\n continue\n multiplier = model.billing.multiplier if model.billing else 1\n print(\n f\"{model.id}: input={prices.input_price} output={prices.output_price} \"\n f\"per {prices.batch_size} tokens (x{multiplier})\"\n )\n```\n\n
\n\n
Go
\n\n```golang\nlist, _ := client.RPC.Models.List(ctx, &rpc.ModelsListRequest{})\n\nfor _, model := range list.Models {\n if model.Billing == nil || model.Billing.TokenPrices == nil {\n continue\n }\n prices := model.Billing.TokenPrices\n multiplier := 1.0\n if model.Billing.Multiplier != nil {\n multiplier = *model.Billing.Multiplier\n }\n in, out := 0.0, 0.0\n if prices.InputPrice != nil {\n in = *prices.InputPrice\n }\n if prices.OutputPrice != nil {\n out = *prices.OutputPrice\n }\n batch := int64(0)\n if prices.BatchSize != nil {\n batch = *prices.BatchSize\n }\n fmt.Printf(\"%s: input=%v output=%v per %d tokens (x%v)\\n\", model.ID, in, out, batch, multiplier)\n}\n```\n\n
\n\n
.NET
\n\n```csharp\nvar list = await client.Rpc.Models.ListAsync();\n\nforeach (var model in list.Models)\n{\n var prices = model.Billing?.TokenPrices;\n if (prices is null) continue;\n Console.WriteLine(\n $\"{model.Id}: input={prices.InputPrice} output={prices.OutputPrice} \" +\n $\"per {prices.BatchSize} tokens (x{model.Billing?.Multiplier ?? 1})\");\n}\n```\n\n
\n\n
Java
\n\n\n\n```java\nvar list = client.getRpc().models.list().join();\n\nfor (var model : list.models()) {\n var billing = model.billing();\n if (billing == null || billing.tokenPrices() == null) {\n continue;\n }\n var prices = billing.tokenPrices();\n double multiplier = billing.multiplier() != null ? billing.multiplier() : 1;\n System.out.printf(\"%s: input=%s output=%s per %d tokens (x%s)%n\",\n model.id(), prices.inputPrice(), prices.outputPrice(), prices.batchSize(), multiplier);\n}\n```\n\n
\n\n
Rust
\n\n```rust\nlet list = client.rpc().models().list().await?;\n\nfor model in &list.models {\n let Some(billing) = &model.billing else { continue };\n let Some(prices) = &billing.token_prices else { continue };\n let multiplier = billing.multiplier.unwrap_or(1.0);\n println!(\n \"{}: input={} output={} per {} tokens (x{multiplier})\",\n model.id,\n prices.input_price.unwrap_or(0.0),\n prices.output_price.unwrap_or(0.0),\n prices.batch_size.unwrap_or(0),\n );\n}\n```\n\n
\n\n
\n\n## Kontokontingent- und Premiuminteraktionen\n\n`account.getQuota`meldet die verbleibende Copilot Berechtigung des authentifizierten Benutzers. Die `quotaSnapshots`-Zuordnung des Ergebnisses ist nach Kontingenttyp indiziert, üblicherweise `premium_interactions`, `chat` und `completions`. Verwenden Sie es, um Benutzern zu zeigen, wie viel von ihrem monatlichen Kontingent noch übrig ist, oder um Arbeit zu blockieren, bevor sie ein Limit erreichen.\n\nIm Beispiel werden die folgenden Felder verwendet; Der generierte `AccountQuotaSnapshot` Typ ist der vollständige Verweis. Die `quotaSnapshots`-Schlüssel sind Zeichenfolgen zur Laufzeit, die vom SDK-Typsystem nicht überprüft werden. Sichern Sie Ihre Zugriffe daher entsprechend ab.\n\n| Feld | Typ | Description |\n| --------------------- | -------- | ------------------------------------------------------------------------------- |\n| `entitlementRequests` | `number` | Anforderungen, die in der Berechtigung enthalten sind, oder `-1` für unbegrenzt |\n| `usedRequests` | `number` | Anforderungen, die bisher in diesem Zeitraum verwendet wurden |\n| `remainingPercentage` | `number` | Prozentsatz der verbleibenden Berechtigung |\n| `resetDate` | `string` | ISO 8601-Datum, an dem das Kontingent zurückgesetzt wird |\n\n> \\[!TIP]\n> Um das Kontingent für einen bestimmten Benutzer anstelle des globalen Authentifizierungskontexts der Verbindung (z. B. in einem multimandantenbasierten Back-End) zu lesen, übergeben Sie das GitHub-Token dieses Benutzers an `getQuota`. Siehe [Mandantenfähigkeit und Serverbereitstellungen](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/multi-tenancy).\n\n
\n
TypeScript
\n\n```typescript\nconst { quotaSnapshots } = await client.rpc.account.getQuota({});\nconst premium = quotaSnapshots[\"premium_interactions\"];\n\nif (premium) {\n console.log(\n `Premium interactions: ${premium.usedRequests}/${premium.entitlementRequests} ` +\n `(${premium.remainingPercentage.toFixed(1)}% left, resets ${premium.resetDate ?? \"n/a\"})`,\n );\n}\n```\n\n
\n\n
Python
\n\n```python\nresult = await client.rpc.account.get_quota(AccountGetQuotaRequest())\npremium = result.quota_snapshots.get(\"premium_interactions\")\n\nif premium is not None:\n print(\n f\"Premium interactions: {premium.used_requests}/{premium.entitlement_requests} \"\n f\"({premium.remaining_percentage:.1f}% left, resets {premium.reset_date or 'n/a'})\"\n )\n```\n\n
\n\n
Go
\n\n```golang\nresult, _ := client.RPC.Account.GetQuota(ctx, &rpc.AccountGetQuotaRequest{})\n\nif premium, ok := result.QuotaSnapshots[\"premium_interactions\"]; ok {\n resets := \"n/a\"\n if premium.ResetDate != nil {\n resets = premium.ResetDate.Format(time.RFC3339)\n }\n fmt.Printf(\"Premium interactions: %d/%d (%.1f%% left, resets %s)\\n\",\n premium.UsedRequests, premium.EntitlementRequests, premium.RemainingPercentage, resets)\n}\n```\n\n
\n\n
.NET
\n\n```csharp\nvar result = await client.Rpc.Account.GetQuotaAsync();\n\nif (result.QuotaSnapshots.TryGetValue(\"premium_interactions\", out var premium))\n{\n Console.WriteLine(\n $\"Premium interactions: {premium.UsedRequests}/{premium.EntitlementRequests} \" +\n $\"({premium.RemainingPercentage:F1}% left, resets {premium.ResetDate?.ToString(\"o\") ?? \"n/a\"})\");\n}\n```\n\n
\n\n
Java
\n\n\n\n```java\nvar result = client.getRpc().account.getQuota().join();\nvar premium = result.quotaSnapshots().get(\"premium_interactions\");\n\nif (premium != null) {\n System.out.printf(\"Premium interactions: %d/%d (%.1f%% left, resets %s)%n\",\n premium.usedRequests(), premium.entitlementRequests(),\n premium.remainingPercentage(), premium.resetDate());\n}\n```\n\n
\n\n
Rust
\n\n```rust\nlet result = client.rpc().account().get_quota().await?;\n\nif let Some(premium) = result.quota_snapshots.get(\"premium_interactions\") {\n let resets = premium.reset_date.as_deref().unwrap_or(\"n/a\");\n println!(\n \"Premium interactions: {}/{} ({:.1}% left, resets {resets})\",\n premium.used_requests, premium.entitlement_requests, premium.remaining_percentage,\n );\n}\n```\n\n
\n\n
\n\n## Auswählen der richtigen API\n\nVerwenden Sie diese Zusammenfassung, um zu entscheiden, welche API zu Ihrem Anwendungsfall passt:\n\n* **Während der Ausführung eines Turns eine Live-Anzeige für Kosten oder Token anzeigen**: Abonnieren Sie `assistant.usage` und `session.usage_info`.\n* **Nach einem Turn oder einer Sitzung eine endgültige Kostenzusammenfassung anzeigen**: Rufen Sie `session.usage.getMetrics` auf.\n* **Beim Wiederaufnehmen die Nutzung des Kontextfensters anzeigen, bevor eine neuer Turn beginnt**: Rufen Sie `session.metadata.contextInfo` auf.\n* **Schätzen Sie die Kosten, bevor Sie die Aufgabe ausführen**: Lesen Sie die `models.list` Tokenpreise.\n* **Warnen Sie Benutzer, bevor sie ihren Plan erschöpfen**: Anruf `account.getQuota`.\n\n## Weiterführende Lektüre\n\n* [Ereignisse einer Streaming-Sitzung](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/streaming-events): vollständige Referenz auf Feldebene für `assistant.usage`, `session.usage_info`und jedes andere Sitzungsereignis\n* [Beobachtbarkeit](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/observability): Exportieren von Nutzungsdaten in OpenTelemetry zur Kostenzuordnung\n* [Mandantenfähigkeit und Serverbereitstellungen](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/multi-tenancy): Auflösen des Kontingents pro Benutzer und Modelle mit einem GitHub-Token"}