# Schnellstart

Vom neuen Konto zur ersten Antwort: Organisation freischalten, Guthaben aufladen, Modell wählen, Key anlegen und Anfrage senden. Der einzige Leitfaden mit der vollständigen Anfrage; die anderen verweisen hierher.

## 1. Organisation freischalten

Registrieren und die E-Mail-Adresse bestätigen. Dann [Firmendaten](https://tokenlane.de/settings/identity) öffnen, Firmenname, Anschrift und Sitzland eintragen und speichern. Die Firmendaten stehen Sitzen in der EU, im EWR und in der Schweiz offen; andere Sitzländer werden vorher geprüft. Guthaben per Checkout kaufen können derzeit Organisationen mit deutschem Sitz; andere Sitzländer brauchen vorher eine Rechnungsprüfung. Die Seite zeigt die Stufe der Organisation, ihre aktuellen Grenzen und den nächsten offenen Schritt.

Eine neue Organisation beginnt auf Stufe T0 und kann noch keine Modelle aufrufen. Mit der ersten bestätigten Zahlung des dort genannten Mindestbetrags wechselt sie automatisch auf T1. Bis dahin scheitert jede Anfrage mit `403 permission_denied` und der Meldung „This organization is suspended“, auch mit gültigem Key.

## 2. Guthaben aufladen

[Guthaben](https://tokenlane.de/settings/credits) öffnen und **Guthaben kaufen** wählen. Vor der Zahlung auf der Checkout-Seite von Mollie zeigt der Dialog die erlaubten Beträge, die Aufladegebühr und die Summe. Das Guthaben erscheint, sobald Mollie die Zahlung bestätigt, nicht schon bei der Rückkehr vom Checkout. Guthaben kaufen können Inhaber und Admins.

Zeigen Dialog und Kontostand **Testmodus**, nimmt diese Instanz Mollie-Testzahlungen an. Testguthaben bleibt vom echten Guthaben getrennt, und eine Testzahlung schaltet die Organisation aus Schritt 1 nicht frei. Um dort Anfragen zu testen, beim Support die Freischaltung anfragen und die Kunden-ID aus den [Firmendaten](https://tokenlane.de/settings/identity) angeben.

## 3. Modell wählen

`GET /v1/models` listet den Katalog ohne Key, [Modelle](https://tokenlane.de/models) ergänzt die Preise in EUR. Eine `id` genau übernehmen, ohne Suffixe wie `:free`. Eine Chat-Anfrage braucht `text` sowohl in `architecture.input_modalities` als auch in `architecture.output_modalities`; Bilder, Dateien, Audio und Embeddings haben eigene Leitfäden. Das Beispiel unten nutzt ein Modell aus dem aktuellen Katalog.

## 4. Inferenz-Key anlegen

[API-Keys](https://tokenlane.de/keys) öffnen, **Neuer Key** wählen und benennen. Unter **Erweiterte Einstellungen** stehen Ablaufdatum, Ausgabenlimit in EUR und erlaubte Modelle. Der Key beginnt mit `sk-tl-v1-` und wird nur einmal angezeigt; er gehört sofort in die Geheimnisverwaltung. Nur ein Inferenz-Key ruft Modelle auf, ein Management-Key kann das nicht. Inferenz-Keys legen Inhaber, Admins und Entwickler an. Key-Arten und Rechte: [Authentifizierung](https://tokenlane.de/docs/guides/authentication.md?lang=de).

## 5. Anfrage senden

Den Key in der Umgebungsvariable `TOKENLANE_API_KEY` ablegen. Node.js und Python nutzen das Paket `openai`, Vercel nutzt `ai` mit `@ai-sdk/openai-compatible`, cURL braucht keine Installation. `YOUR_API_KEY` im cURL-Beispiel ist ein Platzhalter für den eigenen Key, kein gültiger Wert.

### curl

```curl
curl --request POST \
  --url 'https://api.tokenlane.de/v1/chat/completions' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
  "model": "deepseek/deepseek-v4-flash-0731",
  "messages": [
    {
      "role": "user",
      "content": "Hello"
    }
  ],
  "max_tokens": 400
}'
```

### node

```node
import OpenAI from 'openai';

const client = new OpenAI({ baseURL: "https://api.tokenlane.de/v1", apiKey: process.env.TOKENLANE_API_KEY });
const response = await client.chat.completions.create({
  "model": "deepseek/deepseek-v4-flash-0731",
  "messages": [
    {
      "role": "user",
      "content": "Hello"
    }
  ],
  "max_tokens": 400
}, {});
console.log(response);
```

### python

```python
import os
import json
from openai import OpenAI

client = OpenAI(base_url="https://api.tokenlane.de/v1", api_key=os.environ["TOKENLANE_API_KEY"])
body = json.loads(r'''{
  "model": "deepseek/deepseek-v4-flash-0731",
  "messages": [
    {
      "role": "user",
      "content": "Hello"
    }
  ],
  "max_tokens": 400
}''')
response = client.chat.completions.create(
    model=body["model"],
    messages=body["messages"],
    max_tokens=body["max_tokens"]
)
print(response)
```

### vercel

```vercel
import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';

const tokenlane = createOpenAICompatible({ name: 'tokenlane', baseURL: "https://api.tokenlane.de/v1", apiKey: process.env.TOKENLANE_API_KEY, includeUsage: true });
const result = await generateText({
  model: tokenlane("deepseek/deepseek-v4-flash-0731"),
  messages: [
  {
    "role": "user",
    "content": "Hello"
  }
],
  maxOutputTokens: 400,
});
console.log(result.text);
```

Die Antwort steht in `choices[0].message.content`, ihr Preis in `usage.cost` in der Währung aus `usage.currency` (immer `EUR`). Gekürzt sieht eine Antwort so aus; Text, Token-Zahlen und Kosten hängen vom Modell ab:

```json
{
  "id": "gen-01m7kh5a9eepf9045s4a7vehem",
  "model": "deepseek/deepseek-v4-flash-0731",
  "choices": [{ "index": 0, "finish_reason": "stop", "message": { "role": "assistant", "content": "Hallo! Wie kann ich helfen?" } }],
  "usage": { "prompt_tokens": 8, "completion_tokens": 7, "total_tokens": 15, "cost": 0.0000021, "currency": "EUR" }
}
```

Der Header `x-request-id` identifiziert die Anfrage für den Support. Sie erscheint auch in [Aktivität](https://tokenlane.de/activity) und [Logs](https://tokenlane.de/logs).

## Tools

Derselbe Schlüssel und dieselbe Modell-ID funktionieren auch mit diesen OpenAI-kompatiblen Chat-Verbindungen. Als Base-URL `https://api.tokenlane.de/v1` und einen Tokenlane-Inferenzschlüssel eintragen. Ein Chat-Modell aus [Modelle](https://tokenlane.de/models) wählen; Funktionen wie Tool-Aufrufe hängen vom gewählten Modell ab.

| Tool | Verbindungseinstellungen |
| --- | --- |
| LangChain | `ChatOpenAI` aus `langchain-openai` verwenden. `base_url`, `api_key` und `model` setzen. Für Chat Completions `use_responses_api=False` beibehalten. [LangChain-Anleitung](https://docs.langchain.com/oss/python/integrations/chat/openai). |
| Pydantic AI | `OpenAIChatModel` mit einem `OpenAIProvider` verwenden. Am Provider `base_url` und `api_key` setzen, die Modell-ID am `OpenAIChatModel`. [Pydantic-AI-Anleitung](https://ai.pydantic.dev/models/openai/). |
| n8n | Einen **OpenAI Chat Model**-Knoten hinzufügen und OpenAI-Zugangsdaten anlegen. Dort **Base URL** und **API Key** setzen, **Organization ID** leer lassen und die Modell-ID von Hand eintragen. **Use Responses API** ausschalten. [n8n-Anleitung](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatopenai/). |

Diese Verbindungen verwenden `/chat/completions`. Anbietereigene Dienste wie Websuche oder Bildgenerierung werden dadurch nicht freigeschaltet. Die verlinkten Projektanleitungen erklären die Einstellungen; Base-URL, Schlüssel und Modell stammen von Tokenlane.

## Wenn es scheitert

Jeder Fehler trägt `error.metadata.type`, einen `remedy_hint` und die `request_id`. Den Typ auswerten, nicht den Meldungstext.

| Status | `error.metadata.type` | Nächster Schritt |
| --- | --- | --- |
| 400 | `model_not_found` | Die ID aus dem Katalog kopieren; `remedy_hint` nennt die ähnlichste. |
| 401 | `authentication` | `Authorization: Bearer` mit dem Inferenz-Key aus Schritt 4 senden. Fehlender Header, Tippfehler, gesperrter oder abgelaufener Key und Management-Key landen alle hier. |
| 402 | `insufficient_credits` | Guthaben kaufen (Schritt 2) oder das Ausgabenlimit des Keys erhöhen. Das Gateway reserviert zuerst die höchstmöglichen Kosten, deshalb hilft auch ein kleineres `max_tokens`. |
| 403 | `permission_denied` | „This organization is suspended“ bei einer neuen Organisation: Schritt 1 abschließen; die [Firmendaten](https://tokenlane.de/settings/identity) nennen, was offen ist. Sonst schließen die Regeln des Keys das Modell aus, und `remedy_hint` nennt die erlaubten. |
| 404 | `not_found` | Der Pfad stimmt nicht. `https://api.tokenlane.de/v1` als vollständige Base-URL verwenden; `/api/v1` und `/v1/completions` gibt es hier nicht. |
| 429 | `rate_limited` | Die Sekunden aus `Retry-After` abwarten, dann mit Backoff und weniger parallelen Anfragen wiederholen. Die Grenzen der eigenen Stufe stehen in den [Firmendaten](https://tokenlane.de/settings/identity). |

Automatisch nur wiederholen, wenn `error.metadata.retryable` `true` ist, wie bei 429; die anderen Fehler oben brauchen zuerst eine Änderung. Die SDKs melden Fehler als Ausnahmen:

```ts
import OpenAI from 'openai';

try {
  // der Aufruf client.chat.completions.create(...) aus Schritt 5
} catch (error) {
  if (!(error instanceof OpenAI.APIError)) throw error;
  console.error(error.status, error.error?.metadata?.type, error.error?.metadata?.remedy_hint, error.requestID);
}
```

```python
import openai

try:
    ...  # der Aufruf client.chat.completions.create(...) aus Schritt 5
except openai.APIStatusError as error:
    metadata = (error.body or {}).get("metadata", {})
    print(error.status_code, metadata.get("type"), metadata.get("remedy_hint"), error.request_id)
```

Das Vercel AI SDK wirft einen `APICallError` mit `statusCode` und dem Fehler-JSON in `responseBody`. Alle Formate und Regeln für Wiederholungen: [Fehler und Wiederholung](https://tokenlane.de/docs/guides/errors-and-retries.md?lang=de).

## Als Nächstes

- [Streaming](https://tokenlane.de/docs/guides/streaming.md?lang=de)
- [Authentifizierung](https://tokenlane.de/docs/guides/authentication.md?lang=de): Key-Arten, Limits, Ablauf, Verwaltungs-API
- [Von OpenRouter umsteigen](https://tokenlane.de/docs/guides/openrouter-migration.md?lang=de): was sich unterscheidet
- [Kosten und Limits](https://tokenlane.de/docs/guides/costs-and-limits.md?lang=de)