> ## Documentation Index
> Fetch the complete documentation index at: https://docs.venice.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Schnellstart

> Schnellstart für die Venice API — API-Schlüssel generieren, erste Chat-Completion senden und Endpunkte für Bilder, Videos und Audio in Minuten erkunden.

Werde in wenigen Minuten mit der Venice API produktiv. Generiere einen API-Schlüssel, sende deine erste Anfrage und beginne mit dem Entwickeln.

## Schnellstart

<Steps>
  <Step title="API-Schlüssel erhalten">
    Gehe zu deinen [Venice API-Einstellungen](https://venice.ai/settings/api) und generiere einen neuen API-Schlüssel.

    Eine detaillierte Anleitung findest du im [API-Schlüssel-Leitfaden](/guides/getting-started/generating-api-key).
  </Step>

  <Step title="API-Schlüssel einrichten">
    Füge deinen API-Schlüssel zu deiner Umgebung hinzu. Du kannst ihn in deiner Shell exportieren:

    ```bash theme={"system"}
    export VENICE_API_KEY='your-api-key-here'
    ```

    Oder ihn in einer `.env`-Datei in deinem Projekt hinterlegen:

    ```bash theme={"system"}
    VENICE_API_KEY=your-api-key-here
    ```
  </Step>

  <Step title="SDK installieren">
    Venice ist OpenAI-kompatibel, sodass du das OpenAI SDK verwenden kannst. Wenn du lieber cURL oder rohe HTTP-Anfragen nutzt, kannst du diesen Schritt überspringen.

    <CodeGroup>
      ```bash Python theme={"system"}
      pip install openai
      ```

      ```bash Node.js theme={"system"}
      npm install openai
      ```
    </CodeGroup>
  </Step>

  <Step title="Deine erste Anfrage senden">
    <CodeGroup>
      ```python Python theme={"system"}
      import os
      from openai import OpenAI

      client = OpenAI(
          api_key=os.getenv("VENICE_API_KEY"),
          base_url="https://api.venice.ai/api/v1"
      )

      completion = client.chat.completions.create(
          model="zai-org-glm-5",
          messages=[
              {"role": "system", "content": "You are a helpful AI assistant"},
              {"role": "user", "content": "Why is privacy important?"}
          ]
      )

      print(completion.choices[0].message.content)
      ```

      ```javascript Node.js theme={"system"}
      import OpenAI from 'openai';

      const client = new OpenAI({
          apiKey: process.env.VENICE_API_KEY,
          baseURL: 'https://api.venice.ai/api/v1'
      });

      const completion = await client.chat.completions.create({
          model: 'zai-org-glm-5',
          messages: [
              { role: 'system', content: 'You are a helpful AI assistant' },
              { role: 'user', content: 'Why is privacy important?' }
          ]
      });

      console.log(completion.choices[0].message.content);
      ```

      ```bash cURL theme={"system"}
      curl https://api.venice.ai/api/v1/chat/completions \
        -H "Authorization: Bearer $VENICE_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "model": "zai-org-glm-5",
          "messages": [
            {"role": "system", "content": "You are a helpful AI assistant"},
            {"role": "user", "content": "Why is privacy important?"}
          ]
        }'
      ```
    </CodeGroup>

    **Nachrichtenrollen:**

    * `system` – Anweisungen dazu, wie sich das Modell verhalten soll
    * `user` – Deine Prompts oder Fragen
    * `assistant` – Frühere Modellantworten (für mehrstufige Konversationen)
    * `tool` – Ergebnisse von Funktionsaufrufen (bei Verwendung von Tools)
  </Step>

  <Step title="Modelle durch Ändern der Modell-ID wechseln">
    Jede Anfrage enthält eine `model`-ID. Um ein anderes Modell zu verwenden, ändere den `model`-Wert in deiner Anfrage. Beliebte Optionen:

    * `zai-org-glm-5` – Standardmodell für die meisten Anwendungsfälle
    * `kimi-k2-6` – Starkes Reasoning für komplexere Aufgaben
    * `claude-opus-4-8` – Hochintelligentes Modell für komplexe Aufgaben
    * `venice-uncensored-1-2` – Das unzensierte Modell von Venice

    <Card title="Alle Modelle anzeigen" icon="database" href="/overview/models">
      Durchsuche die vollständige Liste der Modelle mit Preisen, Fähigkeiten und Kontextlimits
    </Card>
  </Step>

  <Step title="Venice-Parameter verwenden">
    Du kannst Venice-spezifische Funktionen wie die Websuche über `venice_parameters` aktivieren:

    <CodeGroup>
      ```python Python theme={"system"}
      import os
      from openai import OpenAI

      client = OpenAI(
          api_key=os.environ.get("VENICE_API_KEY"),
          base_url="https://api.venice.ai/api/v1"
      )

      completion = client.chat.completions.create(
          model="zai-org-glm-5",
          messages=[
              {"role": "user", "content": "What are the latest developments in AI?"}
          ],
          extra_body={
              "venice_parameters": {
                  "enable_web_search": "auto",
                  "include_venice_system_prompt": True
              }
          }
      )

      print(completion.choices[0].message.content)
      ```

      ```javascript Node.js theme={"system"}
      import OpenAI from 'openai';

      const client = new OpenAI({
          apiKey: process.env.VENICE_API_KEY,
          baseURL: 'https://api.venice.ai/api/v1'
      });

      const completion = await client.chat.completions.create({
          model: 'zai-org-glm-5',
          messages: [
              { role: 'user', content: 'What are the latest developments in AI?' }
          ],
          venice_parameters: {
              enable_web_search: 'auto',
              include_venice_system_prompt: true
          }
      });

      console.log(completion.choices[0].message.content);
      ```

      ```bash cURL theme={"system"}
      curl https://api.venice.ai/api/v1/chat/completions \
        -H "Authorization: Bearer $VENICE_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "model": "zai-org-glm-5",
          "messages": [
            {"role": "user", "content": "What are the latest developments in AI?"}
          ],
          "venice_parameters": {
            "enable_web_search": "auto",
            "include_venice_system_prompt": true
          }
        }'
      ```
    </CodeGroup>

    Siehe alle [verfügbaren Parameter](https://docs.venice.ai/api-reference/api-spec#venice-parameters).
  </Step>

  <Step title="Streaming aktivieren (optional)">
    Streame Antworten in Echtzeit mit `stream=True`:

    <CodeGroup>
      ```python Python theme={"system"}
      import os
      from openai import OpenAI

      client = OpenAI(
          api_key=os.environ.get("VENICE_API_KEY"),
          base_url="https://api.venice.ai/api/v1"
      )

      stream = client.chat.completions.create(
          model="zai-org-glm-5",
          messages=[{"role": "user", "content": "Write a short story about AI"}],
          stream=True
      )

      for chunk in stream:
          if chunk.choices and chunk.choices[0].delta.content is not None:
              print(chunk.choices[0].delta.content, end="")
      ```

      ```javascript Node.js theme={"system"}
      import OpenAI from 'openai';

      const client = new OpenAI({
          apiKey: process.env.VENICE_API_KEY,
          baseURL: 'https://api.venice.ai/api/v1'
      });

      const stream = await client.chat.completions.create({
          model: 'zai-org-glm-5',
          messages: [{ role: 'user', content: 'Write a short story about AI' }],
          stream: true
      });

      for await (const chunk of stream) {
          if (chunk.choices && chunk.choices[0]?.delta?.content) {
              process.stdout.write(chunk.choices[0].delta.content);
          }
      }
      ```

      ```bash cURL theme={"system"}
      curl https://api.venice.ai/api/v1/chat/completions \
        -H "Authorization: Bearer $VENICE_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "model": "zai-org-glm-5",
          "messages": [
            {"role": "user", "content": "Write a short story about AI"}
          ],
          "stream": true
        }'
      ```
    </CodeGroup>
  </Step>

  <Step title="Antwortverhalten anpassen (optional)">
    Steuere die Modellantwort mit Parametern wie temperature, max tokens und mehr:

    <CodeGroup>
      ```python Python theme={"system"}
      import os
      from openai import OpenAI

      client = OpenAI(
          api_key=os.environ.get("VENICE_API_KEY"),
          base_url="https://api.venice.ai/api/v1"
      )

      completion = client.chat.completions.create(
          model="zai-org-glm-5",
          messages=[
              {"role": "system", "content": "You are a creative storyteller"},
              {"role": "user", "content": "Tell me a creative story"}
          ],
          temperature=0.8,
          max_tokens=500,
          top_p=0.9,
          frequency_penalty=0.5,
          presence_penalty=0.5,
          extra_body={
              "venice_parameters": {
                  "include_venice_system_prompt": False
              }
          }
      )

      print(completion.choices[0].message.content)
      ```

      ```javascript Node.js theme={"system"}
      import OpenAI from 'openai';

      const client = new OpenAI({
          apiKey: process.env.VENICE_API_KEY,
          baseURL: 'https://api.venice.ai/api/v1'
      });

      const completion = await client.chat.completions.create({
          model: 'zai-org-glm-5',
          messages: [
              { role: 'system', content: 'You are a creative storyteller' },
              { role: 'user', content: 'Tell me a creative story' }
          ],
          temperature: 0.8,
          max_tokens: 500,
          top_p: 0.9,
          frequency_penalty: 0.5,
          presence_penalty: 0.5,
          venice_parameters: {
              include_venice_system_prompt: false
          }
      });

      console.log(completion.choices[0].message.content);
      ```

      ```bash cURL theme={"system"}
      curl https://api.venice.ai/api/v1/chat/completions \
        -H "Authorization: Bearer $VENICE_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "model": "zai-org-glm-5",
          "messages": [
            {"role": "system", "content": "You are a creative storyteller"},
            {"role": "user", "content": "Tell me a creative story"}
          ],
          "temperature": 0.8,
          "max_tokens": 500,
          "top_p": 0.9,
          "frequency_penalty": 0.5,
          "presence_penalty": 0.5,
          "stream": false,
          "venice_parameters": {
            "include_venice_system_prompt": false
          }
        }'
      ```
    </CodeGroup>

    Weitere Informationen zu allen unterstützten Parametern findest du in der [Chat-Completions-Dokumentation](/api-reference/endpoint/chat/completions).
  </Step>
</Steps>

***

## Nächste Schritte

Nachdem du deine ersten Anfragen gestellt hast, entdecke, was die Venice API noch zu bieten hat:

<CardGroup cols={2}>
  <Card title="Modelle durchsuchen" icon="database" href="/overview/models">
    Vergleiche alle verfügbaren Modelle hinsichtlich Fähigkeiten, Preisen und Kontextlimits
  </Card>

  <Card title="API-Referenz" icon="code" href="/api-reference/api-spec">
    Erkunde die detaillierte API-Dokumentation mit allen Endpunkten und Parametern
  </Card>

  <Card title="Strukturierte Antworten" icon="brackets-curly" href="/guides/features/structured-responses">
    Erfahre, wie du JSON-Antworten mit garantierten Schemas erhältst
  </Card>

  <Card title="Leitfaden für KI-Agenten" icon="robot" href="/guides/integrations/ai-agents">
    Entwickle mit Agenten-Apps, Coding-Agenten, MCP-Tools, Skills und Krypto-Workflows
  </Card>
</CardGroup>

### Weitere Ressourcen

<CardGroup cols={2}>
  <Card title="Ratenbegrenzung" icon="gauge" href="/api-reference/rate-limiting">
    Verstehe Ratenlimits und Best Practices für den Produktivbetrieb
  </Card>

  <Card title="Fehlercodes" icon="triangle-exclamation" href="/api-reference/error-codes">
    Referenz zum Umgang mit API-Fehlern und zur Problembehandlung
  </Card>

  <Card title="Postman-Sammlung" icon="bolt" href="/guides/getting-started/postman">
    Importiere unsere vollständige Postman-Sammlung für einfaches Testen
  </Card>

  <Card title="Datenschutz & Sicherheit" icon="shield" href="/overview/privacy">
    Erfahre mehr über die datenschutzorientierte Architektur von Venice und den Umgang mit Daten
  </Card>
</CardGroup>

***

## Brauchst du Hilfe?

* **Discord-Community**: Tritt unserem [Discord-Server](https://discord.gg/askvenice) für Support und Diskussionen bei
* **Dokumentation**: Durchsuche unsere [vollständige API-Referenz](/api-reference/api-spec)
* **Statusseite**: Prüfe den Servicestatus auf [veniceai-status.com](https://veniceai-status.com)
* **Twitter**: Folge [@AskVenice](https://x.com/AskVenice) für Updates

<Resources />