# Python: das OpenAI SDK auf Open-Weight-Modelle gerichtet

> Open-Weight-LLMs aus Python mit dem openai-Paket aufrufen: ein Aufruf, asynchrone Batches mit begrenzter Nebenläufigkeit, Streaming und Kosten pro Anfrage.

- URL: https://llmwithcrypto.com/de/docs/python/
- Zuletzt aktualisiert: 2026-10-23
- Herausgeber: LLMwithCrypto (https://llmwithcrypto.com)

Das offizielle `openai`-Paket funktioniert unverändert: Übergeben Sie unsere Base URL und Ihren Key, wenn Sie den Client erstellen. Alles andere in Ihrem Code bleibt gleich, abgesehen vom Modellnamen.

**Kurze Antwort — Wie rufe ich LLMwithCrypto aus Python auf?**

Installieren Sie das offizielle Paket mit `pip install openai` und erstellen Sie dann den Client mit `base_url="https://llmwithcrypto.com/api/v1"` und Ihrem Key aus `LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** antwortet auf `client.chat.completions.create()` wie die OpenAI API, für 12 Open-Weight-Modelle wie `deepseek-v4-pro` oder `gpt-oss-120b`. Streaming, async und Tool-Calls funktionieren wie gewohnt, wie am 23. Oktober 2026 dokumentiert.

## Was Sie brauchen

| Attribut | Wert |
| --- | --- |
| Python | 3.9 oder neuer |
| Paket | `openai` (offiziell); `requests` für den credits-Aufruf |
| Base URL | `https://llmwithcrypto.com/api/v1` |
| Key | In der Umgebungsvariable `LLMWITHCRYPTO_API_KEY`, niemals im Code |
| Modell-IDs | Auf der [Modellseite](https://llmwithcrypto.com/de/models/) oder aus `client.models.list()` |

## Wie sende ich eine einzelne Anfrage?

Erstellen Sie den Client einmal und verwenden Sie ihn wieder: Er hält die Verbindung zwischen den Aufrufen offen. Das SDK liest hier von sich aus keine Umgebungsvariable für die Base URL, übergeben Sie sie daher explizit.

*one_call.py*

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Answer in two sentences."},
        {"role": "user", "content": "What is a context window?"},
    ],
    max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, "in,", resp.usage.completion_tokens, "out")

```

## Wie führe ich viele Anfragen gleichzeitig aus?

Verwenden Sie `AsyncOpenAI` mit `asyncio.gather` und ein Semaphore, um zu begrenzen, wie viele Anfragen parallel laufen. Vier sind ein sicherer Start; erhöhen Sie die Zahl, solange Sie unter Ihrem rate limit bleiben. Jedes Konto hat ein Anfrage- und Token-Limit pro Minute, das im Dashboard angezeigt wird; fragen Sie den Support, dann kann es erhöht werden.

*many_calls.py*

```python
import asyncio
import os

from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
LIMIT = asyncio.Semaphore(4)


async def summarize(text):
    async with LIMIT:
        resp = await client.chat.completions.create(
            model="deepseek-v4.1-flash",
            messages=[
                {"role": "system", "content": "Summarize in one sentence."},
                {"role": "user", "content": text},
            ],
            max_tokens=80,
        )
        return resp.choices[0].message.content


async def main():
    docs = ["First report text...", "Second report text...", "Third report text..."]
    for summary in await asyncio.gather(*(summarize(d) for d in docs)):
        print("-", summary)


asyncio.run(main())

```

## Wie streame ich die Antwort?

Übergeben Sie `stream=True` und iterieren Sie über die Chunks; jeder trägt ein Stück Text in `delta.content`. Mit `stream_options={"include_usage": True}` trägt der letzte Chunk die Token-Zählungen. Die [Streaming-Seite](https://llmwithcrypto.com/de/docs/streaming/) erklärt das Format.

*stream.py*

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

stream = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Write a haiku about latency."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=120,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.prompt_tokens, "in,", chunk.usage.completion_tokens, "out")

```

## Woher weiß ich, was eine Anfrage gekostet hat?

Multiplizieren Sie die `usage`-Zählungen mit den Preisen des Modells pro Million Token. Stand 23. Oktober 2026 kostet DeepSeek V4 Pro $1.254 pro Million Input-Token und $3.762 pro Million Output-Token; das Beispiel schreibt diese beiden Zahlen fest, also aktualisieren Sie sie von der [Preisseite](https://llmwithcrypto.com/de/pricing/), wenn sich die Preise ändern. Das Dashboard zeigt die genauen Kosten jedes Aufrufs.

*cost.py*

```python
import os

from openai import OpenAI

# prices per 1M tokens of the models you use, copied from the pricing page
PRICES = {"deepseek-v4-pro": (1.254, 3.762)}

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Give me three names for a coffee shop."}],
    max_tokens=100,
)
price_in, price_out = PRICES[resp.model]
cost = (resp.usage.prompt_tokens * price_in + resp.usage.completion_tokens * price_out) / 1_000_000
print(resp.choices[0].message.content)
print(f"cost: ${cost:.6f}")

```

## Wie stelle ich eine bestehende OpenAI-App um?

Drei Änderungen, meist in einer Datei:

1. **Der Client.** Fügen Sie `base_url` hinzu und lesen Sie den Schlüssel aus `LLMWITHCRYPTO_API_KEY` dort, wo Sie `OpenAI()` oder `AsyncOpenAI()` erzeugen.
2. **Die Modellnamen.** Ersetzen Sie jeden `gpt-…`-Namen durch eine id von der [Modelle-Seite](https://llmwithcrypto.com/de/models/). Durchsuchen Sie das gesamte Projekt: Modellnamen verstecken sich in Konfigurationsdateien, Prompts und Tests.
3. **Die Funktionen, auf die Sie sich verlassen.** Chat, Streaming und System-Prompts funktionieren überall. Tool Calling und JSON-Ausgabe hängen vom Modell ab, also führen Sie Ihre vorhandenen Tests gegen das gewählte Modell aus.

Alles andere bleibt: Ihre Prompts, Ihre Retry-Logik, Ihr Parsing von `choices` und `usage`. Der [Umstiegsleitfaden](https://llmwithcrypto.com/de/guides/switch-openai-sdk-to-open-models/) führt durch die Details.

## Wo sollte der Schlüssel liegen?

In der Umgebung, niemals im Code. Lokal genügt eine `.env`-Datei, die Ihre App lädt und die in `.gitignore` aufgeführt ist; in der Produktion nutzen Sie den Secret Store Ihres Hosts oder CI. Geben Sie jeder App oder jedem Service einen eigenen Schlüssel, damit Sie einen widerrufen können, ohne die anderen zu stoppen. Legen Sie einen API-Schlüssel pro App, Agent oder Teammitglied an und widerrufen Sie jeden davon im Dashboard, ohne die anderen zu berühren.

## Python: häufige Fragen

### Wiederholt das SDK Fehler von selbst?

Ja, das Paket `openai` wiederholt bestimmte Fehler standardmäßig zweimal (`max_retries`). Die [Fehlerseite](https://llmwithcrypto.com/de/docs/errors/) listet, welche Fehler eine Wiederholung wert sind.

### Kann ich meinen OpenAI-Code weiterverwenden?

Ja. Die API spricht das OpenAI chat completions-Format: Richten Sie das OpenAI SDK, LangChain oder ein beliebiges OpenAI-kompatibles Tool mit Ihrem API-Schlüssel auf unsere Base-URL und ändern Sie den Modellnamen. Der [Umstiegsleitfaden](https://llmwithcrypto.com/de/guides/switch-openai-sdk-to-open-models/) listet, was Sie prüfen sollten.

### Welche Python-Frameworks funktionieren?

Alles, was eine OpenAI-kompatible base URL akzeptiert. Die [LangChain-Seite](https://llmwithcrypto.com/de/docs/langchain/) zeigt LangChain und LlamaIndex.

---

LLMwithCrypto: LLMwithCrypto ist eine OpenAI-kompatible LLM-API für Open-Weight-Modelle — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — pro Token aus einem vorausbezahlten Krypto-Guthaben bezahlt, 5 % unter dem Medianpreis der öffentlichen Hosts. Ohne KYC: kein Ausweis, kein Selfie, keine Dokumente. Prompts und Ausgaben werden nicht gespeichert.