Generate content

POST

v1beta

models

{model}

{operator}

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="gemini-3.8-flash",
    contents='Explain how AI works in a few words',
)

print(response.text)

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "AI learns patterns from massive amounts of data to make predictions, solve problems, and generate new content. \n\nIn short: **Data in → Patterns found → Smart predictions out.**"
          }
        ]
      },
      "finishReason": "STOP"
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 9,
    "candidatesTokenCount": 36,
    "thoughtsTokenCount": 388,
    "totalTokenCount": 433
  },
  "modelVersion": "gemini-3.8-flash"
}

Use the Gemini native request format through CometAPI to generate text, send video input, and configure thinking or tools. The examples use gemini-3.8-flash.

Use Google’s GenerateContent API reference for field definitions and model-specific options. This page shows the CometAPI base URL, authentication, and request examples.

Both x-goog-api-key and Authorization: Bearer headers are supported for authentication.

Quick start

To use the Google Gen AI SDK or an HTTP client with CometAPI, configure the base URL and API key:

Setting	Google default	CometAPI
Base URL	`generativelanguage.googleapis.com`	`api.cometapi.com`
API key	`$GEMINI_API_KEY`	`$COMETAPI_KEY`

Use the GenerateContent text generation guide for native API examples. Keep the generateContent request shape when changing the base URL.

Send video input

Send video as a content part. Choose the input shape based on where the video is stored:

Video source	Request part	Use when
Local video file	`inlineData`	The video is small enough to send as base64 in the JSON request.
Public video URL	`fileData.fileUri`	The video is available through a public HTTPS URL that does not require authentication.

For REST and curl requests, use camelCase field names such as inlineData.mimeType and fileData.fileUri.

This example sends inline MP4 data. Replace <base64-encoded-mp4> with the base64 contents of your video:

curl \
  "https://api.cometapi.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $COMETAPI_KEY" \
  --data-binary @- <<'EOF'
{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "inlineData": {
            "mimeType": "video/mp4",
            "data": "<base64-encoded-mp4>"
          }
        },
        {
          "text": "Analyze this video and list the key scenes."
        }
      ]
    }
  ],
  "generationConfig": {
    "maxOutputTokens": 2048,
    "thinkingConfig": {
      "thinkingLevel": "LOW"
    }
  }
}
EOF

This example analyzes a public MP4 of a flower opening:

curl \
  "https://api.cometapi.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $COMETAPI_KEY" \
  --data-binary @- <<'EOF'
{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "fileData": {
            "mimeType": "video/mp4",
            "fileUri": "https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4"
          }
        },
        {
          "text": "Analyze this video and list the key scenes."
        }
      ]
    }
  ],
  "generationConfig": {
    "maxOutputTokens": 2048,
    "thinkingConfig": {
      "thinkingLevel": "LOW"
    }
  }
}
EOF

Configure thinking (reasoning)

Use thinkingConfig.thinkingLevel to guide reasoning depth. The examples below use LOW and MEDIUM.

Thinking level
Thinking summaries

This example sets the thinking level to LOW:

curl \
  "https://api.cometapi.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $COMETAPI_KEY" \
  --data-binary @- <<'EOF'
{
  "contents": [
    {
      "parts": [
        {
          "text": "How does quantum computing work?"
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
      "thinkingLevel": "LOW"
    }
  }
}
EOF

Set includeThoughts to request a thinking summary. When the response includes a summary, its text part has thought: true:

curl \
  "https://api.cometapi.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $COMETAPI_KEY" \
  --data-binary @- <<'EOF'
{
  "contents": [
    {
      "parts": [
        {
          "text": "What is the 10th Fibonacci number when F(0)=0 and F(1)=1? Briefly verify the result."
        }
      ]
    }
  ],
  "generationConfig": {
    "maxOutputTokens": 4096,
    "thinkingConfig": {
      "thinkingLevel": "MEDIUM",
      "includeThoughts": true
    }
  }
}
EOF

thinkingBudget is a numeric control for compatible models, including Gemini 2.5. Use thinkingLevel in the Gemini 3 examples and do not send both controls. See Google’s thinking guide for model-specific values.

Stream responses

Use streamGenerateContent?alt=sse to receive Server-Sent Events. Each data: line contains a JSON GenerateContentResponse object:

curl \
  "https://api.cometapi.com/v1beta/models/gemini-3.8-flash:streamGenerateContent?alt=sse" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $COMETAPI_KEY" \
  --no-buffer \
  --data-binary @- <<'EOF'
{
  "contents": [
    {
      "parts": [
        {
          "text": "Write a short poem about the stars"
        }
      ]
    }
  ]
}
EOF

Set system instructions

Use systemInstruction to guide the response. This example requests one equation without additional text:

curl \
  "https://api.cometapi.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $COMETAPI_KEY" \
  --data-binary @- <<'EOF'
{
  "contents": [
    {
      "parts": [
        {
          "text": "What is 2+2?"
        }
      ]
    }
  ],
  "systemInstruction": {
    "parts": [
      {
        "text": "You are a math tutor. Answer with exactly one equation and no other text."
      }
    ]
  }
}
EOF

Request JSON output

Set responseMimeType to application/json and provide a responseSchema. This example requests an array of planets with names and numeric distances:

curl \
  "https://api.cometapi.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $COMETAPI_KEY" \
  --data-binary @- <<'EOF'
{
  "contents": [
    {
      "parts": [
        {
          "text": "Return a JSON array of 3 planets with name and average_distance_from_sun_au."
        }
      ]
    }
  ],
  "generationConfig": {
    "responseMimeType": "application/json",
    "responseSchema": {
      "type": "ARRAY",
      "items": {
        "type": "OBJECT",
        "properties": {
          "name": {
            "type": "STRING",
            "description": "Name of the planet."
          },
          "average_distance_from_sun_au": {
            "type": "NUMBER",
            "description": "Average distance from the Sun, in astronomical units."
          }
        },
        "required": [
          "name",
          "average_distance_from_sun_au"
        ]
      }
    }
  }
}
EOF

Ground with Google Search

Add a googleSearch tool to request search grounding. This example asks for the result of the UEFA EURO 2024 final:

curl \
  "https://api.cometapi.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $COMETAPI_KEY" \
  --data-binary @- <<'EOF'
{
  "contents": [
    {
      "parts": [
        {
          "text": "Use Google Search to find the winner and final score of the UEFA EURO 2024 final. Cite your sources."
        }
      ]
    }
  ],
  "tools": [
    {
      "googleSearch": {}
    }
  ],
  "generationConfig": {
    "maxOutputTokens": 2048
  }
}
EOF

When search is used, inspect the candidate’s groundingMetadata for search queries, source URLs, and links between sources and response text.

Preserve conversation content

For multi-turn conversations, send the preceding user and model content in contents. The SDK chat examples maintain this history for you. For function calling, return one functionResponse for each functionCall, with the matching name and any returned id. Pass the preceding model content back unchanged, including thoughtSignature fields. The signature is opaque; do not reconstruct it from displayed text.

Response example

A text response includes generated content and token usage. This abbreviated example omits optional fields:

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "AI learns patterns from massive amounts of data to make predictions, solve problems, and generate new content. \n\nIn short: **Data in → Patterns found → Smart predictions out.**"
          }
        ]
      },
      "finishReason": "STOP"
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 9,
    "candidatesTokenCount": 36,
    "thoughtsTokenCount": 388,
    "totalTokenCount": 433
  },
  "modelVersion": "gemini-3.8-flash"
}

thoughtsTokenCount reports internal thinking tokens, even when the response does not include a thinking summary. Inspect each content part; a response can contain text, summaries, or function calls.

Compare request formats

Choose the native endpoint for Gemini request and response fields. See Chat Completions for the OpenAI-compatible format.

Field	Gemini native	OpenAI-compatible chat
Conversation input	`contents` with `parts`	`messages`
Model ID	In the request path	`model` in the request body
Generated content	`candidates` with `content.parts`	`choices` with `message`

Authorizations

x-goog-api-key

string

header

required

Your CometAPI key passed via the x-goog-api-key header. Bearer token authentication (Authorization: Bearer $COMETAPI_KEY) is also supported.

Path Parameters

model

string

default:gemini-3.8-flash

required

Gemini model ID. These examples use gemini-3.8-flash. See the Models page for available model IDs.

operator

enum<string>

default:generateContent

required

Operation to perform. Use generateContent for a JSON response. For Server-Sent Events, select streamGenerateContent and set the separate alt query parameter to sse.

Available options:

generateContent,

streamGenerateContent

Query Parameters

alt

enum<string>

Set to sse when the operator is streamGenerateContent. Omit this parameter for generateContent.

Available options:

sse

Body

application/json

contents

object[]

Conversation content. Each entry has an optional role (user or model) and a parts array. For tool results, preserve the complete preceding model content, including any thoughtSignature fields.

Show child attributes

systemInstruction

object

System instructions that guide the model's behavior across the entire conversation. Text only.

Show child attributes

tools

object[]

Tools available to the model during generation. Use googleSearch for search grounding.

Show child attributes

toolConfig

object

Configuration for tool usage, such as function calling mode.

Show child attributes

safetySettings

object[]

Safety filter settings. Override default thresholds for specific harm categories.

Show child attributes

generationConfig

object

Configuration for model generation behavior including temperature, output length, and response format.

Show child attributes

cachedContent

string

The name of cached content to use as context. Format: cachedContents/{id}. See the Gemini context caching documentation for details.

Response

200 - application/json

Successful response. For streaming requests, the response is a stream of SSE events, each containing a GenerateContentResponse JSON object prefixed with data:.

candidates

object[]

The generated response candidates.

Show child attributes

promptFeedback

object

Feedback on the prompt, including safety blocking information.

Show child attributes

usageMetadata

object

Token usage statistics for the request.

Show child attributes

modelVersion

string

The model version that generated this response.

createTime

string

The timestamp when this response was created (ISO 8601 format).

responseId

string

Unique identifier for this response.

Last modified on September 7, 2026

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="gemini-3.8-flash",
    contents='Explain how AI works in a few words',
)

print(response.text)

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "AI learns patterns from massive amounts of data to make predictions, solve problems, and generate new content. \n\nIn short: **Data in → Patterns found → Smart predictions out.**"
          }
        ]
      },
      "finishReason": "STOP"
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 9,
    "candidatesTokenCount": 36,
    "thoughtsTokenCount": 388,
    "totalTokenCount": 433
  },
  "modelVersion": "gemini-3.8-flash"
}

Content moderation

API keys

Quick start

Send video input

Configure thinking (reasoning)

Stream responses

Set system instructions

Request JSON output

Ground with Google Search

Preserve conversation content

Response example

Compare request formats

Authorizations

Path Parameters

Query Parameters

Body

Response

​Quick start

​Send video input

​Configure thinking (reasoning)

​Stream responses

​Set system instructions

​Request JSON output

​Ground with Google Search

​Preserve conversation content

​Response example

​Compare request formats

Authorizations

Path Parameters

Query Parameters

Body

Response

Quick start

Send video input

Configure thinking (reasoning)

Stream responses

Set system instructions

Request JSON output

Ground with Google Search

Preserve conversation content

Response example

Compare request formats