gemini-3-6-flash

Quick example

curl https://reapi.ai/api/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.6-flash",
    "messages": [
      { "role": "user", "content": "Summarise the benefits of API rate limiting in five bullets." }
    ],
    "stream": true,
    "max_tokens": 8192
  }'

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://reapi.ai/api/v1",
)

stream = client.chat.completions.create(
    model="gemini-3.6-flash",
    messages=[{"role": "user", "content": "Summarise the benefits of API rate limiting in five bullets."}],
    max_tokens=8192,
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="")

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://reapi.ai/api/v1",
});

const stream = await client.chat.completions.create({
  model: "gemini-3.6-flash",
  messages: [
    { role: "user", content: "Summarise the benefits of API rate limiting in five bullets." },
  ],
  max_tokens: 8192,
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]any{
        "model": "gemini-3.6-flash",
        "messages": []map[string]string{
            {"role": "user", "content": "Summarise the benefits of API rate limiting in five bullets."},
        },
        "max_tokens": 8192,
    })
    req, _ := http.NewRequest("POST",
        "https://reapi.ai/api/v1/chat/completions", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    fmt.Println(string(out))
}

Authentication

Use an API key from your current reAPI account and send it as a bearer token:

Authorization: Bearer YOUR_API_KEY

Endpoint

POST /api/v1/chat/completions

Public URL https://reapi.ai/api/v1/chat/completions. For OpenAI SDKs, set the base URL to https://reapi.ai/api/v1. The current wire format is compatible with the exposed pure-text subset of Chat Completions, so the same SDKs (openai-python, openai-node, openai-go, …) work once you set the base URL, your reAPI key, and the model string.

Parameter support on this model

The request body is forwarded as written, so any Chat Completions field reaches the model. These are the ones this model answers differently — each verified by calling it on 2026-08-25:

Nothing in the Chat Completions format is rejected by this model; every field tested was accepted.

Request body

model — string, required

Must be gemini-3.6-flash exactly. The dotted form is the wire id; the /models/gemini-3-6-flash landing page uses a hyphenated slug for the URL.

messages — array, required

Conversation history in the standard Chat Completions shape. The gateway requires only that the array is present and non-empty; the entries themselves are forwarded as written, so message fields, roles, and content-part arrays follow the upstream model's contract rather than a separate gateway rule.

max_tokens / max_completion_tokens — integer

Upper bound on output tokens for this response, thinking tokens included. The current reAPI billing-safety cap is 8,192, even though Google's model ceiling is higher. A value above 8,192 is rejected with a 400 — the gateway never silently rewrites a request into a different cost than the one you asked for. max_tokens is deprecated in the OpenAI spec in favour of max_completion_tokens; both are accepted here, and when both are present the smaller one wins.

stream — boolean, default false

When true, tokens arrive as server-sent events terminated by data: [DONE]. Recommended for anything a person watches.

Every other field

The request body is forwarded as written. Send any field the Chat Completions format defines — temperature, top_p, frequency_penalty, presence_penalty, seed, stop, reasoning_effort, logit_bias, logprobs, response_format, tools, tool_choice, n, and so on — with the types and ranges that format defines. The gateway does not keep a field whitelist, so a parameter added to the format later works here without waiting for a gateway release.

Two consequences worth stating plainly:

• omit a field and the model's own default applies — nothing is substituted for you;
• send a value the model does not accept and you get the model's error, not a reworded gateway one.

Verified working through this endpoint: function calling (tools returns tool_calls with finish_reason: "tool_calls") and JSON mode (response_format: { "type": "json_object" }).

stream_options

Accepted but always overridden: the endpoint sends stream_options: { include_usage: true } upstream, because the usage frame is what the request is billed from. A request that suppressed it could not be billed at all.

Official multimodal capability vs current endpoint

Google documents the following model-level inputs. The gateway forwards content parts as written, so what reaches the model is what you sent:

Output is text only. Image generation is not supported by this model; use a dedicated image model when the result itself must be an image.

Thinking

Thinking is a Google model capability. reasoning_effort is forwarded like every other field, and the model may also reason internally without being asked to.

Official tools vs current endpoint

"Forwarded, not verified" means the request reaches the model untouched — the gateway blocks nothing — but we have not tested that capability end to end, so treat the model's own response as the answer on whether it works.

These rows describe Google's underlying model, not callable features on the current reAPI route. Requests to this endpoint should contain only the documented pure-text chat fields above.

Pricing dimensions

Billing is per token against your current reAPI account, with separate input and output rates. Two things to keep in mind:

• Thinking tokens bill as output. They are the usual reason a bill exceeds an estimate built from visible response length alone.
• Output can dominate. For generative workloads, response length and any thinking tokens can materially affect the final charge.

Current rates are on the model page. That live table is the canonical pricing source; this page intentionally does not duplicate a fixed price.

Response shape

Non-streaming (stream: false)

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1785000000,
  "model": "gemini-3.6-flash",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "..." },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 812,
    "completion_tokens": 240,
    "total_tokens": 1052
  }
}

usage.completion_tokens includes thinking tokens, so it is the number to reconcile a bill against.

Streaming (stream: true)

Server-sent events, each data: line carrying a chat.completion.chunk with the incremental text in choices[0].delta.content, terminated by data: [DONE].

Errors

Failures use reAPI's standard error envelope. See the errors catalog for the full code list. Common cases:

Tips

• Stream anything interactive. Time-to-first-token is what users perceive; a non-streamed long answer reads as a hang.
• Budget for thinking. If responses truncate on hard prompts, use a max_tokens value up to the current 8,192-token cap and ask for a more concise answer when necessary.
• Send source text directly. The current endpoint does not accept image, audio, video, or PDF content parts.
• Keep requests to the documented subset. The current route is a pure-text Chat Completions surface rather than the full Google model API.
• Pin the Stable string. gemini-3.6-flash is Google's Stable channel id; latest-style aliases can be hot-swapped underneath you.

Related

• Gemini 3.6 Flash model page — current rates
• Errors catalog
• Authentication
• Quickstart