Gemini 4 Argon · API

Quick start

Two steps: send a request, then stream the answer. Replace YOUR_API_KEY with your key and the commands below run as they are. The endpoint matches OpenAI Chat Completions, so existing OpenAI code only needs a new base_url and model.

Step 1 · Send a request

curl https://kovapi.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-4-argon", "messages": [{"role": "user", "content": "Explain photosynthesis in one sentence"}]}'

Response (HTTP 200)

{
  "id": "chatcmpl-7f3c9a1e2b4d6f8a",
  "object": "chat.completion",
  "created": 1791281400,
  "model": "gemini-4-argon",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Photosynthesis is how plants use sunlight to turn carbon dioxide and water into sugar, releasing oxygen.",
        "reasoning_content": "..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 186,
    "total_tokens": 204,
    "prompt_tokens_details": {"cached_tokens": 0},
    "completion_tokens_details": {"reasoning_tokens": 144}
  }
}

message.content is the answer and message.reasoning_content the thinking. usage holds the tokens this request is billed for: thinking tokens are part of completion_tokens and bill at the output price.

Step 2 · Stream the answer (recommended)

curl -N https://kovapi.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-4-argon", "stream": true, "messages": [{"role": "user", "content": "Explain photosynthesis in one sentence"}]}'

The stream is standard SSE: each chunk carries text in choices[0].delta.content, the last chunk carries usage, and it ends with data: [DONE]. Stream long answers and thinking models: a non-streaming request is cut off after about 10 minutes.

Python (OpenAI SDK)

from openai import OpenAI

client = OpenAI(base_url="https://kovapi.com/v1", api_key="YOUR_API_KEY")

# 1. One request, one answer
resp = client.chat.completions.create(
    model="gemini-4-argon",
    messages=[{"role": "user", "content": "Explain photosynthesis in one sentence"}],
)
print(resp.choices[0].message.content)

# 2. Streaming
stream = client.chat.completions.create(
    model="gemini-4-argon",
    messages=[{"role": "user", "content": "Explain photosynthesis in one sentence"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Authentication

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Create an API Key in the console to start.

At a glance

Request parameters

The JSON body of POST /v1/chat/completions, the same as OpenAI Chat Completions. The common parameters, and what each one does on this model:

Start with the parameters listed here. Function calling, multimodal input and JSON mode are not currently promised; for web search, see the Web search section below.

Price

Billed per token at the live rates below (per million tokens). Only successful requests are billed, on actual usage: failures, timeouts and refusals are free. 1 credit = $0.005.

For example, a request with 2,000 input tokens and 1,000 output tokens (thinking included) costs about $0.004.

Thinking

Set reasoning_effort to low, medium or high; omitted values default to low.

Visible thinking is returned in reasoning_content. usage.completion_tokens includes thinking and answer tokens; do not add thinking tokens a second time.

All levels have the same rates. Higher thinking effort may consume more output tokens.

Thinking tokens are part of usage.completion_tokens and bill at the output price (some models also break them out in completion_tokens_details.reasoning_tokens).

{
  "model": "gemini-4-argon",
  "messages": [{"role": "user", "content": "Explain photosynthesis in one sentence"}],
  "reasoning_effort": "medium"
}

Prompt caching

Automatic implicit caching is supported. Repeated long inputs may hit the cache; actual hits cost one tenth of the normal input rate. Repetition does not guarantee a hit, and explicit cache creation is not provided.

usage.prompt_tokens is total input. usage.prompt_tokens_details.cached_tokens is the cached portion of that total. Only actual hits use the cached rate.

Web search

Web search on Gemini 4 Argon uses Google Search: add "web_search": true to the request, or pass {"type": "web_search"} in tools. Sources come back in message.annotations (when streaming, in delta.annotations of the last chunk) in OpenAI's url_citation format, and the number of searches actually run is in usage.server_tool_use.web_search_requests. Each search costs $0.0035 on top of the normal token charge; the model decides whether and how often to search.

curl https://kovapi.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-4-argon", "web_search": true, "messages": [{"role": "user", "content": "What are the main tech news stories today"}]}'

Beta limits

• Text chat, streaming, three thinking levels and Google Search have been verified. Function calling, multimodal input and JSON mode remain unverified.
• The official context is about 1M tokens shared by input and output. Long-input retrieval has passed testing; the full window and million-token output have not been tested.
• Split long tasks. max_tokens is not a verified hard budget limit. Failed requests are not billed; interrupted requests that produced output settle at actual usage.

Errors and refunds

Errors come back as an error object (message, type, code, param); decide by the HTTP status and code, never by matching the text of message. Failed requests are not billed; the full list is in Error codes.

If a stream fails after it started sending, the status code stays as it was: the error arrives as a data line carrying error, or the stream just ends (without data: [DONE]). Treat it as interrupted.