# BYOK (Bring Your Own Key)

BYOK ermöglicht es Ihnen, das Copilot SDK mit Ihren eigenen API-Schlüsseln von Modellanbietern zu verwenden, um GitHub Copilot Authentifizierung zu umgehen. Dies ist nützlich für Unternehmensbereitstellungen, benutzerdefiniertes Modellhosting oder wenn Sie eine direkte Abrechnung mit Ihrem Modellanbieter wünschen.

<!-- markdownlint-disable GHD046 GHD005 -->

<!-- Suppressed: GHD046 (outdated release terminology), GHD005 (hardcoded data variable) -->

## Unterstützte Anbieter

| Provider                            | Typwert                 | Hinweise                                                                     |
| ----------------------------------- | ----------------------- | ---------------------------------------------------------------------------- |
| OpenAI                              | `"openai"`              | OpenAI-API und openAI-kompatible Endpunkte                                   |
| Azure OpenAI / Azure AI Foundry     |                         |                                                                              |
| `"azure"`                           | Azure gehostete Modelle |                                                                              |
| Anthropic                           | `"anthropic"`           | Claude Modelle                                                               |
| Ollama                              | `"openai"`              | Lokale Modelle mittels OpenAI-kompatibler API                                |
| Microsoft Entwicklungszentrum Local | `"openai"`              | Lokales Ausführen von KI-Modellen auf Ihrem Gerät über openAI-kompatible API |
| Andere OpenAI-kompatible Produkte   | `"openai"`              | vLLM, LiteLLM usw.                                                           |

## Schnellstart: Azure AI Foundry

Azure AI Foundry
(früher Azure OpenAI) ist ein gängiges BYOK-Bereitstellungsziel für Unternehmen. Hier ist ein vollständiges Beispiel:

<div class="ghd-codetabs">
<div class="ghd-codetab" data-lang="python" data-label="Python"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Python</div>

```python
import asyncio
import os
from copilot import CopilotClient
from copilot.session import PermissionHandler

FOUNDRY_MODEL_URL = "https://your-resource.openai.azure.com/openai/v1/"
# Set FOUNDRY_API_KEY environment variable

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-5.2-codex", provider={
        "type": "openai",
        "base_url": FOUNDRY_MODEL_URL,
        "wire_api": "responses",  # Use "completions" for older models
        "api_key": os.environ["FOUNDRY_API_KEY"],
    })

    done = asyncio.Event()

    def on_event(event):
        if event.type.value == "assistant.message":
            print(event.data.content)
        elif event.type.value == "session.idle":
            done.set()

    session.on(on_event)
    await session.send("What is 2+2?")
    await done.wait()

    await session.disconnect()
    await client.stop()

asyncio.run(main())
```

</div>

<div class="ghd-codetab" data-lang="typescript" data-label="TypeScript"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">TypeScript</div>

```typescript
import { CopilotClient } from "@github/copilot-sdk";

const FOUNDRY_MODEL_URL = "https://your-resource.openai.azure.com/openai/v1/";

const client = new CopilotClient();
const session = await client.createSession({
    model: "gpt-5.2-codex",  // Your deployment name
    provider: {
        type: "openai",
        baseUrl: FOUNDRY_MODEL_URL,
        wireApi: "responses",  // Use "completions" for older models
        apiKey: process.env.FOUNDRY_API_KEY,
    },
});

session.on("assistant.message", (event) => {
    console.log(event.data.content);
});

await session.sendAndWait({ prompt: "What is 2+2?" });
await client.stop();
```

</div>

<div class="ghd-codetab" data-lang="go" data-label="Go"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Go</div>

```golang
package main

import (
    "context"
    "fmt"
    "os"
    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    if err := client.Start(ctx); err != nil {
        panic(err)
    }
    defer client.Stop()

    session, err := client.CreateSession(ctx, &copilot.SessionConfig{
        Model: "gpt-5.2-codex",  // Your deployment name
        Provider: &copilot.ProviderConfig{
            Type:    "openai",
            BaseURL: "https://your-resource.openai.azure.com/openai/v1/",
            WireAPI: "responses",  // Use "completions" for older models
            APIKey:  os.Getenv("FOUNDRY_API_KEY"),
        },
    })
    if err != nil {
        panic(err)
    }

    response, err := session.SendAndWait(ctx, copilot.MessageOptions{
        Prompt: "What is 2+2?",
    })
    if err != nil {
        panic(err)
    }

    if d, ok := response.Data.(*copilot.AssistantMessageData); ok {
        fmt.Println(d.Content)
    }
}
```

</div>

<div class="ghd-codetab" data-lang="dotnet" data-label=".NET"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">.NET</div>

```csharp
using GitHub.Copilot;

await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    Model = "gpt-5.2-codex",  // Your deployment name
    Provider = new ProviderConfig
    {
        Type = "openai",
        BaseUrl = "https://your-resource.openai.azure.com/openai/v1/",
        WireApi = "responses",  // Use "completions" for older models
        ApiKey = Environment.GetEnvironmentVariable("FOUNDRY_API_KEY"),
    },
});

var response = await session.SendAndWaitAsync(new MessageOptions
{
    Prompt = "What is 2+2?",
});
Console.WriteLine(response?.Data.Content);
```

</div>

<div class="ghd-codetab" data-lang="java" data-label="Java"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Java</div>

```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;

var client = new CopilotClient();
client.start().get();

var session = client.createSession(new SessionConfig()
    .setModel("gpt-5.2-codex")  // Your deployment name
    .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
    .setProvider(new ProviderConfig()
        .setType("openai")
        .setBaseUrl("https://your-resource.openai.azure.com/openai/v1/")
        .setWireApi("responses")  // Use "completions" for older models
        .setApiKey(System.getenv("FOUNDRY_API_KEY")))
).get();

var response = session.sendAndWait(new MessageOptions()
    .setPrompt("What is 2+2?")).get();
System.out.println(response.getData().content());

client.stop().get();
```

</div>

</div>

## Anbieterkonfigurationsreferenz

### ProviderConfig-Felder

| Feld                                                                                                                                                                                                                                                                                                                                                    | Typ    | Description                                             |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | ------------------------------------------------------- |
| `type`                                                                                                                                                                                                                                                                                                                                                  |        |                                                         |
| `"openai"`                                                                                                                                                                                                                                                                                                                                              |        |                                                         |
| \|                                                                                                                                                                                                                                                                                                                                                      |        |                                                         |
| `"azure"`                                                                                                                                                                                                                                                                                                                                               |        |                                                         |
| \|                                                                                                                                                                                                                                                                                                                                                      |        |                                                         |
| `"anthropic"`                                                                                                                                                                                                                                                                                                                                           |        |                                                         |
| Anbietertyp (Standard: `"openai"`)                                                                                                                                                                                                                                                                                                                      |        |                                                         |
| `baseUrl` / `base_url`                                                                                                                                                                                                                                                                                                                                  | string |                                                         |
| **Erforderlich**. API-Endpunkt-URL                                                                                                                                                                                                                                                                                                                      |        |                                                         |
| `apiKey` / `api_key`                                                                                                                                                                                                                                                                                                                                    | string | API-Schlüssel (optional für lokale Anbieter wie Ollama) |
| `bearerToken` / `bearer_token`                                                                                                                                                                                                                                                                                                                          | string | Bearertokenauthentifizierung (hat Vorrang vor apiKey)   |
| `wireApi` / `wire_api`                                                                                                                                                                                                                                                                                                                                  |        |                                                         |
| `"completions"`                                                                                                                                                                                                                                                                                                                                         |        |                                                         |
| \|                                                                                                                                                                                                                                                                                                                                                      |        |                                                         |
| `"responses"`                                                                                                                                                                                                                                                                                                                                           |        |                                                         |
| Wählen Sie `"completions"` für breite Modellkompatibilität (die Chat Completions API); wählen Sie `"responses"` für die Verwaltung des Konversationsstatus über mehrere Dialogrunden hinweg, Tool-Namensräume und Reasoning-Unterstützung (die Responses API). Anthropic Modelle verwenden unabhängig von dieser Einstellung immer die Nachrichten-API. |        |                                                         |
| `azure.apiVersion` / `azure.api_version`                                                                                                                                                                                                                                                                                                                | string | Azure API-Version (Standard: `"2024-10-21"`)            |

### Draht-API-Format

Die `wireApi` Einstellung bestimmt, welches OpenAI-API-Format verwendet werden soll:

* **`"completions"`** (Standard) – API für Chat-Vervollständigungen (`/chat/completions`) für umfassende Modellkompatibilität.
* **`"responses"`** - Responses API für die Verwaltung von Multi-Turn-Kontexten, Tool-Namensräumen und die Unterstützung für Reasoning.

Anthropic Modelle verwenden unabhängig von dieser Einstellung immer die Anthropic Nachrichten-API.

### Typspezifische Notizen

**OpenAI (`type: "openai"`)**

* Funktioniert mit der OpenAI-API und jedem openAI-kompatiblen Endpunkt
* `baseUrl` sollte den vollständigen Pfad enthalten (z. B. `https://api.openai.com/v1`)

**Azure (`type: "azure"`)**

* Verwendung für systemeigene Azure OpenAI-Endpunkte
* `baseUrl` sollte nur der Host sein (z. B. `https://my-resource.openai.azure.com`)
* Fügen Sie `/openai/v1` NICHT in die URL ein – das SDK übernimmt die Pfaderstellung

**Anthropic (`type: "anthropic"`)**

* Für direkten Anthropic-API-Zugriff
* Verwendet claudespezifisches API-Format

## Beispielkonfigurationen

### OpenAI direct

```typescript
provider: {
    type: "openai",
    baseUrl: "https://api.openai.com/v1",
    apiKey: process.env.OPENAI_API_KEY,
}
```

### Azure OpenAI (nativer Azure-Endpunkt)

Verwenden Sie `type: "azure"` für Endpunkte bei `*.openai.azure.com`:

```typescript
provider: {
    type: "azure",
    baseUrl: "https://my-resource.openai.azure.com",  // Just the host
    apiKey: process.env.AZURE_OPENAI_KEY,
    azure: {
        apiVersion: "2024-10-21",
    },
}
```

### Azure AI Foundry

(OpenAI-kompatibler Endpunkt)

Für Azure AI Foundry
-Bereitstellungen mit `/openai/v1/` Endpunkten, verwenden Sie `type: "openai"`.

```typescript
provider: {
    type: "openai",
    baseUrl: "https://your-resource.openai.azure.com/openai/v1/",
    apiKey: process.env.FOUNDRY_API_KEY,
    wireApi: "responses",  // For GPT-5 series models
}
```

### Ollama (lokal)

```typescript
provider: {
    type: "openai",
    baseUrl: "http://localhost:11434/v1",
    // No apiKey needed for local Ollama
}
```

### Microsoft Entwicklungszentrum Local

mit [Microsoft Foundry Local](https://foundrylocal.ai) können Sie KI-Modelle lokal auf Ihrem eigenen Gerät mit einer openAI-kompatiblen API ausführen. Installieren Sie es über das Foundry Local CLI und richten Sie das SDK dann auf Ihren lokalen Endpunkt aus.

```typescript
provider: {
    type: "openai",
    baseUrl: "http://localhost:<PORT>/v1",
    // No apiKey needed for local Foundry Local
}
```

> \[!NOTE]
> Foundry Local startet auf einem **dynamischen Port** – der Port ist nicht behoben. Verwenden Sie `foundry service status`, um zu bestätigen, an welchem Port der Dienst derzeit lauscht, und verwenden Sie dann diesen Port in Ihrem `baseUrl`.

Erste Schritte mit Foundry Local:

```bash
# Windows: Install Foundry Local CLI (requires winget)
winget install Microsoft.FoundryLocal

# macOS / Linux: see https://foundrylocal.ai for installation instructions
# List available models
foundry model list

# Run a model (starts the local server automatically)
foundry model run phi-4-mini

# Check the port the service is running on
foundry service status
```

### Anthropic

```typescript
provider: {
    type: "anthropic",
    baseUrl: "https://api.anthropic.com",
    apiKey: process.env.ANTHROPIC_API_KEY,
}
```

### Bearertokenauthentifizierung

Einige Anbieter erfordern die Bearertokenauthentifizierung anstelle von API-Schlüsseln:

```typescript
provider: {
    type: "openai",
    baseUrl: "https://my-custom-endpoint.example.com/v1",
    bearerToken: process.env.MY_BEARER_TOKEN,  // Sets Authorization header
}
```

> \[!NOTE]
> Die `bearerToken` Option akzeptiert nur eine **statische Tokenzeichenfolge** . Das SDK aktualisiert dieses Token nicht automatisch. Wenn Ihr Token abläuft, schlagen Anforderungen fehl, und Sie müssen eine neue Sitzung mit einem neuen Token erstellen.

## Auflistung benutzerdefinierter Modelle

Bei Verwendung von BYOK weiß der CLI-Server möglicherweise nicht, welche Modelle Ihr Anbieter unterstützt. Sie können einen benutzerdefinierten `onListModels` Handler auf Clientebene bereitstellen, sodass die `client.listModels()` Modelle Ihres Anbieters im Standardformat `ModelInfo` zurückgegeben werden. Auf diese Weise können nachgeschaltete Verbraucher verfügbare Modelle ermitteln, ohne die CLI abfragen zu müssen.

<div class="ghd-codetabs">
<div class="ghd-codetab" data-lang="typescript" data-label="TypeScript"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">TypeScript</div>

```typescript
import { CopilotClient } from "@github/copilot-sdk";
import type { ModelInfo } from "@github/copilot-sdk";

const client = new CopilotClient({
    onListModels: () => [
        {
            id: "my-custom-model",
            name: "My Custom Model",
            capabilities: {
                supports: { vision: false, reasoningEffort: false },
                limits: { max_context_window_tokens: 128000 },
            },
        },
    ],
});
```

</div>

<div class="ghd-codetab" data-lang="python" data-label="Python"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Python</div>

```python
from copilot import CopilotClient
from copilot.client import ModelInfo, ModelCapabilities, ModelSupports, ModelLimits

client = CopilotClient(
    on_list_models=lambda: [
        ModelInfo(
            id="my-custom-model",
            name="My Custom Model",
            capabilities=ModelCapabilities(
                supports=ModelSupports(vision=False, reasoning_effort=False),
                limits=ModelLimits(max_context_window_tokens=128000),
            ),
        )
    ],
)
```

</div>

<div class="ghd-codetab" data-lang="go" data-label="Go"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Go</div>

```golang
package main

import (
    "context"
    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    client := copilot.NewClient(&copilot.ClientOptions{
        OnListModels: func(ctx context.Context) ([]copilot.ModelInfo, error) {
            return []copilot.ModelInfo{
                {
                    ID:   "my-custom-model",
                    Name: "My Custom Model",
                    Capabilities: copilot.ModelCapabilities{
                        Supports: copilot.ModelSupports{Vision: false, ReasoningEffort: false},
                        Limits:   copilot.ModelLimits{MaxContextWindowTokens: 128000},
                    },
                },
            }, nil
        },
    })
    _ = client
}
```

</div>

<div class="ghd-codetab" data-lang="dotnet" data-label=".NET"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">.NET</div>

```csharp
using GitHub.Copilot;

var client = new CopilotClient(new CopilotClientOptions
{
    OnListModels = (ct) => Task.FromResult<IList<ModelInfo>>(new List<ModelInfo>
    {
        new()
        {
            Id = "my-custom-model",
            Name = "My Custom Model",
            Capabilities = new ModelCapabilities
            {
                Supports = new ModelSupports { Vision = false, ReasoningEffort = false },
                Limits = new ModelLimits { MaxContextWindowTokens = 128000 }
            }
        }
    })
});
```

</div>

<div class="ghd-codetab" data-lang="java" data-label="Java"><div class="ghd-codetab-fallback-label" role="heading" aria-level="3">Java</div>

```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
import java.util.List;
import java.util.concurrent.CompletableFuture;

var client = new CopilotClient(new CopilotClientOptions()
    .setOnListModels(() -> CompletableFuture.completedFuture(List.of(
        new ModelInfo()
            .setId("my-custom-model")
            .setName("My Custom Model")
            .setCapabilities(new ModelCapabilities()
                .setSupports(new ModelSupports().setVision(false).setReasoningEffort(false))
                .setLimits(new ModelLimits().setMaxContextWindowTokens(128000)))
    )))
);
```

</div>

</div>

Ergebnisse werden nach dem ersten Aufruf wie das Standardverhalten zwischengespeichert. Der Handler ersetzt das RPC der CLI `models.list` vollständig – es erfolgt kein Fallback auf den Server.

## Einschränkungen

Beachten Sie bei der Verwendung von BYOK die folgenden Einschränkungen:

### Identitätseinschränkungen

BYOK-Authentifizierung verwendet **nur statische Anmeldeinformationen**.

Sie müssen einen API-Schlüssel oder statisches Bearertoken verwenden, das Sie selbst verwalten.

### Featurebeschränkungen

Einige Copilot Features verhalten sich mit BYOK möglicherweise anders:

* **Modellverfügbarkeit** – Es sind nur Modelle verfügbar, die von Ihrem Anbieter unterstützt werden.
* **Ratenbegrenzung** – Abhängig von den Ratenlimits Ihres Anbieters, nicht von denen von Copilot
* **Nachverfolgung** – Die Nutzung wird von Ihrem Anbieter nachverfolgt, nicht GitHub Copilot
* **Premiumanfragen** – werden nicht auf die Kontingente für Copilot-Premiumanfragen angerechnet

### Anbieterspezifische Einschränkungen

| Provider                                                       | Einschränkungen                                                                                     |
| -------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| Azure AI Foundry                                               |                                                                                                     |
| Keine Entra ID Authentifizierung; muss API-Schlüssel verwenden |                                                                                                     |
| Ollama                                                         | Kein API-Schlüssel; nur lokal; Modellunterstützung variiert                                         |
| [Microsoft Foundry Local](https://foundrylocal.ai)             | Nur lokal; Die Modellverfügbarkeit hängt von der Gerätehardware ab; kein API-Schlüssel erforderlich |
| OpenAI                                                         | Vorbehaltlich von OpenAI-Tariflimits und -quoten                                                    |

## Troubleshooting

### Fehler "Modell nicht angegeben"

Bei Verwendung von BYOK ist der `model` Parameter **erforderlich**:

```typescript
// ❌ Error: Model required with custom provider
const session = await client.createSession({
    provider: { type: "openai", baseUrl: "..." },
});

// ✅ Correct: Model specified
const session = await client.createSession({
    model: "gpt-4",  // Required!
    provider: { type: "openai", baseUrl: "..." },
});
```

### Verwirrung beim Azure-Endpunkttyp

Verwenden Sie für Azure OpenAI-Endpunkte (`*.openai.azure.com`) den richtigen Typ:

<!-- docs-validate: hidden -->

```typescript
import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({
    model: "gpt-4.1",
    provider: {
        type: "azure",
        baseUrl: "https://my-resource.openai.azure.com",
    },
});
```

<!-- /docs-validate: hidden -->

```typescript
// ❌ Wrong: Using "openai" type with native Azure endpoint
provider: {
    type: "openai",  // This won't work correctly
    baseUrl: "https://my-resource.openai.azure.com",
}

// ✅ Correct: Using "azure" type
provider: {
    type: "azure",
    baseUrl: "https://my-resource.openai.azure.com",
}
```

Wenn Ihre Azure AI Foundry
-Bereitstellung jedoch einen openAI-kompatiblen Endpunktpfad (z. B. `/openai/v1/`) bereitstellt, verwenden Sie `type: "openai"`:

<!-- docs-validate: hidden -->

```typescript
import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({
    model: "gpt-4.1",
    provider: {
        type: "openai",
        baseUrl: "https://your-resource.openai.azure.com/openai/v1/",
    },
});
```

<!-- /docs-validate: hidden -->

```typescript
// ✅ Correct: OpenAI-compatible Azure AI Foundry endpoint
provider: {
    type: "openai",
    baseUrl: "https://your-resource.openai.azure.com/openai/v1/",
}
```

### Verbindung verweigert (Ollama)

Stellen Sie sicher, dass Ollama ausgeführt wird und barrierefrei ist:

```bash
# Check Ollama is running
curl http://localhost:11434/v1/models

# Start Ollama if not running
ollama serve
```

### Verbindung verweigert (Foundry Local)

Foundry Local verwendet einen dynamischen Port, der sich zwischen Neustarts ändern kann. Bestätigen Sie den aktiven Port:

```bash
# Check the service status and port
foundry service status
```

Aktualisieren Sie Ihr `baseUrl`, damit es mit dem in der Ausgabe angezeigten Port übereinstimmt. Wenn der Dienst nicht ausgeführt wird, starten Sie ein Modell, um es zu starten:

```bash
foundry model run phi-4-mini
```

### Fehler bei der Authentifizierung.

1. Überprüfen, ob Der API-Schlüssel korrekt und nicht abgelaufen ist
2. Überprüfen Sie, ob `baseUrl` dem von Ihrem Anbieter erwarteten Format entspricht.
3. Stellen Sie für Bearertoken sicher, dass das vollständige Token bereitgestellt wird (nicht nur ein Präfix)

## Nächste Schritte

* [Authentication](/de/copilot/how-tos/copilot-sdk/auth) – Erfahren Sie mehr über alle Authentifizierungsmethoden
* [Erstellen Sie Ihre erste Copilot-gestützte App](/de/copilot/how-tos/copilot-sdk/getting-started) – Erstellen Ihrer ersten Copilot-basierten App