> ## 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-snelstart: gebruik native en OpenAI-compatibele requests met CometAPI

> Roep Gemini-tekstmodellen aan via CometAPI met native generateContent-requests of OpenAI-compatibele Chat Completions-requests.

## Wat je gaat bouwen

Je stuurt een native Gemini `POST /v1beta/models/\{model\}:generateContent`-request en vergelijkt die vervolgens met de OpenAI-compatibele `POST /v1/chat/completions`-optie voor apps die al Chat Completions-requestvormen gebruiken.

## Vereisten

* Een CometAPI API-sleutel opgeslagen in `COMETAPI_KEY`
* Een Gemini-tekstmodel model ID van de [Models page](/nl/overview/models)
* `curl`, Python 3.10+, of Node.js 18+

## API-sleutel, basis-URL, authenticatie

Gebruik de native Gemini-endpoint wanneer je Gemini-requestvelden wilt gebruiken:

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

Gebruik `x-goog-api-key` voor directe native Gemini HTTP-requests:

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

Gebruik de OpenAI-compatibele basis-URL alleen wanneer je applicatie al Chat Completions gebruikt:

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

## Native Gemini-indeling

Native Gemini-requests gebruiken `contents`, `parts` en `generationConfig`. Gebruik dit pad wanneer je Gemini-specifieke velden nodig hebt, zoals thinking-controls, media-onderdelen, Google Search-grounding of native streaming-operators.

<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-compatibele optie

Gebruik de OpenAI-compatibele route wanneer je een bestaande OpenAI SDK- of Chat Completions-app migreert en geen native Gemini-requestvelden nodig hebt.

<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>

## Uitleg van de flow

| Pad               | Endpoint                                        | Requestvorm                                        | SDK                              | Gebruik wanneer                                                                                                   |
| ----------------- | ----------------------------------------------- | -------------------------------------------------- | -------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| Gemini native     | `POST /v1beta/models/\{model\}:generateContent` | `contents`, `parts`, `generationConfig`            | Google GenAI SDK of directe HTTP | Je Gemini-specifieke velden, multimodale onderdelen, thinking-controls, grounding of native streaming nodig hebt. |
| OpenAI-compatibel | `POST /v1/chat/completions`                     | `messages`, `temperature`, `max_completion_tokens` | OpenAI SDK of directe HTTP       | Je app al Chat Completions gebruikt en alleen een Gemini-tekstmodel achter die vorm nodig heeft.                  |

Mix de twee requestindelingen niet. Native Gemini-velden zoals `contents` en `generationConfig` horen bij de `generateContent`-route. Chat Completions-velden zoals `messages` horen bij de OpenAI-compatibele route.

## Probleemoplossing / FAQ

<AccordionGroup>
  <Accordion title="Met welk pad moet ik beginnen">
    Begin met native Gemini `generateContent` wanneer je een nieuwe Gemini-workflow bouwt. Gebruik de OpenAI-compatibele route wanneer een bestaande app al afhankelijk is van OpenAI SDK of Chat Completions-requestvormen.
  </Accordion>

  <Accordion title="Native Gemini-velden falen op Chat Completions">
    Stuur `contents`, `parts`, `generationConfig` en `streamGenerateContent`-requests naar de native Gemini-endpoint. De OpenAI-compatibele route verwacht `messages` en Chat Completions-parameters.
  </Accordion>

  <Accordion title="Het Gemini-model model ID faalt">
    Controleer of het model ID beschikbaar is voor je account en de route ondersteunt die je aanroept. Gebruik de [Models page](/nl/overview/models) om actuele model IDs te vinden.
  </Accordion>

  <Accordion title="De SDK wijst naar de verkeerde service">
    Stel voor Google GenAI SDK-requests de basis-URL in op `https://api.cometapi.com`. Stel voor OpenAI SDK-requests `base_url` in Python of `baseURL` in Node.js in op `https://api.cometapi.com/v1`.
  </Accordion>
</AccordionGroup>

## Volgende stappen

* Gebruik de [Gemini native API reference](/api/text/gemini-generating-content) voor volledige `generateContent`-request- en responsevelden.
* Lees de [Chat Completions API reference](/api/text/chat) voor de OpenAI-compatibele requestvorm.
* Configureer OpenAI SDK-clients in [Use CometAPI with OpenAI SDKs](/nl/guides/use-cometapi-with-openai-sdk).
* Toon beschikbare modellen met [List available CometAPI models](/nl/guides/how-to-list-available-models).
* Voeg retry- en rate-limit-afhandeling toe met [Error codes and retry strategy](/nl/guides/error-codes-and-retry-strategy).