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

# Gemini API-Kurzanleitung: Verwenden Sie native und OpenAI-kompatible Requests mit CometAPI

> Rufen Sie Gemini-Textmodelle über CometAPI mit nativen generateContent-Requests oder OpenAI-kompatiblen Chat Completions-Requests auf.

## Was Sie erstellen werden

Sie senden einen nativen Gemini-Request an `POST /v1beta/models/\{model\}:generateContent` und vergleichen ihn anschließend mit der OpenAI-kompatiblen Option `POST /v1/chat/completions` für Apps, die bereits Chat Completions-Request-Formate verwenden.

## Voraussetzungen

* Ein in `COMETAPI_KEY` gespeicherter CometAPI-API-Schlüssel
* Eine Gemini-Textmodell-ID von der [Modellseite](/de/overview/models)
* `curl`, Python 3.10+ oder Node.js 18+

## API-Schlüssel, base URL, Authentifizierung

Verwenden Sie den nativen Gemini-Endpunkt, wenn Sie Gemini-Request-Felder verwenden möchten:

```text theme={null}
https://api.cometapi.com/v1beta/models/{model}:generateContent
```

Verwenden Sie `x-goog-api-key` für direkte native Gemini-HTTP-Requests:

```text theme={null}
x-goog-api-key: $COMETAPI_KEY
```

Verwenden Sie die OpenAI-kompatible base URL nur, wenn Ihre Anwendung bereits Chat Completions verwendet:

```text theme={null}
https://api.cometapi.com/v1
```

## Natives Gemini-Format

Native Gemini-Requests verwenden `contents`, `parts` und `generationConfig`. Verwenden Sie diesen Pfad, wenn Sie Gemini-spezifische Felder wie Thinking-Steuerungen, Medienteile, Google Search Grounding oder native Streaming-Operatoren benötigen.

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://api.cometapi.com/v1beta/models/your-gemini-model-id:generateContent" \
    -H "x-goog-api-key: $COMETAPI_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "contents": [
        {
          "parts": [
            {
              "text": "Explain why base URL configuration matters."
            }
          ]
        }
      ],
      "generationConfig": {
        "temperature": 0.3
      }
    }'
  ```

  ```python Python theme={null}
  import os
  from google import genai

  client = genai.Client(
      api_key=os.environ["COMETAPI_KEY"],
      http_options={"api_version": "v1beta", "base_url": "https://api.cometapi.com"},
  )

  response = client.models.generate_content(
      model="your-gemini-model-id",
      contents="Explain why base URL configuration matters.",
      config={
          "temperature": 0.3,
      },
  )

  print(response.text)
  ```

  ```javascript Node.js theme={null}
  import { GoogleGenAI } from "@google/genai";

  const ai = new GoogleGenAI({
    apiKey: process.env.COMETAPI_KEY,
    httpOptions: {
      baseUrl: "https://api.cometapi.com",
      apiVersion: "v1beta",
    },
  });

  const response = await ai.models.generateContent({
    model: "your-gemini-model-id",
    contents: "Explain why base URL configuration matters.",
    config: {
      temperature: 0.3,
    },
  });

  console.log(response.text);
  ```
</CodeGroup>

## OpenAI-kompatible Option

Verwenden Sie die OpenAI-kompatible Route, wenn Sie eine bestehende OpenAI SDK- oder Chat Completions-App migrieren und keine nativen Gemini-Request-Felder benötigen.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.cometapi.com/v1/chat/completions \
    -H "Authorization: Bearer $COMETAPI_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "your-gemini-model-id",
      "messages": [
        {
          "role": "user",
          "content": "Explain why base URL configuration matters."
        }
      ]
    }'
  ```

  ```python Python theme={null}
  import os
  from openai import OpenAI

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

  completion = client.chat.completions.create(
      model="your-gemini-model-id",
      messages=[
          {
              "role": "user",
              "content": "Explain why base URL configuration matters.",
          }
      ],
  )

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

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

  const client = new OpenAI({
    apiKey: process.env.COMETAPI_KEY,
    baseURL: "https://api.cometapi.com/v1",
  });

  const completion = await client.chat.completions.create({
    model: "your-gemini-model-id",
    messages: [
      {
        role: "user",
        content: "Explain why base URL configuration matters.",
      },
    ],
  });

  console.log(completion.choices[0].message.content);
  ```
</CodeGroup>

## Erklärung des Ablaufs

| Pfad              | Endpunkt                                        | Request-Format                                     | SDK                                 | Verwenden, wenn                                                                                                    |
| ----------------- | ----------------------------------------------- | -------------------------------------------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| Gemini nativ      | `POST /v1beta/models/\{model\}:generateContent` | `contents`, `parts`, `generationConfig`            | Google GenAI SDK oder direktes HTTP | Sie Gemini-spezifische Felder, Multimodal-Teile, Thinking-Steuerungen, Grounding oder natives Streaming benötigen. |
| OpenAI-kompatibel | `POST /v1/chat/completions`                     | `messages`, `temperature`, `max_completion_tokens` | OpenAI SDK oder direktes HTTP       | Ihre App bereits Chat Completions verwendet und nur ein Gemini-Textmodell hinter diesem Format benötigt.           |

Mischen Sie die beiden Request-Formate nicht. Native Gemini-Felder wie `contents` und `generationConfig` gehören auf die Route `generateContent`. Chat Completions-Felder wie `messages` gehören auf die OpenAI-kompatible Route.

## Fehlerbehebung / FAQ

<AccordionGroup>
  <Accordion title="Mit welchem Pfad sollte ich beginnen">
    Beginnen Sie mit dem nativen Gemini-`generateContent`, wenn Sie einen neuen Gemini-Workflow erstellen. Verwenden Sie die OpenAI-kompatible Route, wenn eine bestehende App bereits von OpenAI SDK oder Chat Completions-Request-Formaten abhängt.
  </Accordion>

  <Accordion title="Native Gemini-Felder schlagen bei Chat Completions fehl">
    Senden Sie `contents`-, `parts`-, `generationConfig`- und `streamGenerateContent`-Requests an den nativen Gemini-Endpunkt. Die OpenAI-kompatible Route erwartet `messages` und Chat Completions-Parameter.
  </Accordion>

  <Accordion title="Die Gemini-Modell-ID schlägt fehl">
    Bestätigen Sie, dass die Modell-ID für Ihr Konto verfügbar ist und die Route unterstützt, die Sie aufrufen. Verwenden Sie die [Modellseite](/de/overview/models), um aktuelle Modell-IDs zu finden.
  </Accordion>

  <Accordion title="Das SDK zeigt auf den falschen Dienst">
    Setzen Sie für Google GenAI SDK-Requests die base URL auf `https://api.cometapi.com`. Setzen Sie für OpenAI SDK-Requests `base_url` in Python oder `baseURL` in Node.js auf `https://api.cometapi.com/v1`.
  </Accordion>
</AccordionGroup>

## Nächste Schritte

* Verwenden Sie die [Gemini native API reference](/api/text/gemini-generating-content) für vollständige `generateContent`-Request- und Response-Felder.
* Lesen Sie die [Chat Completions API reference](/api/text/chat) für das OpenAI-kompatible Request-Format.
* Konfigurieren Sie OpenAI SDK-Clients in [Use CometAPI with OpenAI SDKs](/de/guides/use-cometapi-with-openai-sdk).
* Listen Sie verfügbare Modelle mit [List available CometAPI models](/de/guides/how-to-list-available-models) auf.
* Fügen Sie Wiederholungs- und Rate-Limit-Behandlung mit [Error codes and retry strategy](/de/guides/error-codes-and-retry-strategy) hinzu.