Gemini 3.8 Flash · 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://nezhagate.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-3.8-flash", "messages": [{"role": "user", "content": "Explain photosynthesis in one sentence"}]}'

Response (HTTP 200)

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

message.content is the answer. usage holds the tokens this request is billed for; prompt_tokens_details.cached_tokens is the part served from the cache and billed at the cache price.

Step 2 · Stream the answer (recommended)

curl -N https://nezhagate.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-3.8-flash", "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://nezhagate.com/v1", api_key="YOUR_API_KEY")

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

# 2. Streaming
stream = client.chat.completions.create(
    model="gemini-3.8-flash",
    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:

Other OpenAI parameters (such as stop, seed, user) are passed to the model as sent; whether they take effect is up to the model.

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

Thinking

Dynamic thinking: the model decides how much to think per question, quick on easy ones and deeper on hard ones, with no extra parameter. Thinking tokens count against the output budget, so do not set max_tokens too low.

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

Prompt caching

No parameter needed: a repeated long prefix (the same system prompt, the earlier turns of a conversation) may be cached by the model provider automatically, and the cached part bills at the lower cache price. Whether and how much is cached is up to the provider; keep the parts that never change at the start of the messages for the best hit rate.

The cached token count comes back in usage.prompt_tokens_details.cached_tokens; that part bills at the cache-hit price and the rest of the input at the input price.

Image input

Put an image_url part in the content array. A base64 data URI (data:image/png;base64,...) is the recommended form and every line can read it; a public image link has to be downloaded by the line, and an occasional line cannot fetch it or times out. Images count as input tokens by the provider rules.

curl https://nezhagate.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-3.8-flash", "messages": [{"role": "user", "content": [{"type": "text", "text": "What is in this image"}, {"type": "image_url", "image_url": {"url": "data:image/png;base64,iVBORw0KGgo..."}}]}]}'

Web search

Add "web_search": true to the request (or a {"type": "web_search"} entry in tools): the gateway first searches the live web based on the conversation, hands up to 5 results with their links to the model as reference, and the model answers and cites its sources. The search itself is free; the reference text bills as input tokens.

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

Lines and reliability

• Every model runs on several lines. When one errors, times out or is full, the gateway moves to the next line before anything is returned, so you need not retry and are never billed twice.
• Once a stream starts sending, it stays on its line: if it breaks partway, you are billed for the usage produced up to that point (see Billing and refunds).
• When every line is full the gateway returns 429 with Retry-After; wait that many seconds and retry. Failed requests are not billed. Each model status is on the status page.

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.