Gemini Native Format

POST

models

{model}

:generateContent

curl -X POST https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent \
  -H "x-goog-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {"text": "解释一下冒泡排序算法。"}
        ]
      }
    ],
    "generationConfig": {
      "temperature": 0.7,
      "maxOutputTokens": 1024
    }
  }'

import google.generativeai as genai

genai.configure(
    api_key="YOUR_API_KEY",
    transport="rest",
    client_options={"api_endpoint": "https://www.qingbo.dev/v1"}
)

model = genai.GenerativeModel("gemini-2.5-flash")

response = model.generate_content(
    "解释一下冒泡排序算法。",
    generation_config={
        "temperature": 0.7,
        "max_output_tokens": 1024
    }
)

print(response.text)

import { GoogleGenerativeAI } from '@google/generative-ai';

const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
const model = genAI.getGenerativeModel({
  model: 'gemini-2.5-flash',
  baseUrl: 'https://www.qingbo.dev/v1'
});

const result = await model.generateContent({
  contents: [{
    role: 'user',
    parts: [{ text: '解释一下冒泡排序算法。' }]
  }],
  generationConfig: {
    temperature: 0.7,
    maxOutputTokens: 1024
  }
});

console.log(result.response.text());

package main

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

func main() {
    payload := map[string]interface{}{
        "contents": []map[string]interface{}{
            {
                "role": "user",
                "parts": []map[string]string{
                    {"text": "解释一下冒泡排序算法。"},
                },
            },
        },
        "generationConfig": map[string]interface{}{
            "temperature":    0.7,
            "maxOutputTokens": 1024,
        },
    }

    body, _ := json.Marshal(payload)
    url := "https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent"
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
    req.Header.Set("x-goog-api-key", "YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    result, _ := io.ReadAll(resp.Body)
    fmt.Println(string(result))
}

import java.net.http.*;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String payload = """
        {
          "contents": [
            {
              "role": "user",
              "parts": [{"text": "解释一下冒泡排序算法。"}]
            }
          ],
          "generationConfig": {
            "temperature": 0.7,
            "maxOutputTokens": 1024
          }
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent"))
            .header("x-goog-api-key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

The Gemini native format API provides a native interface for interacting with Google Gemini models, supporting multimodal input and advanced features.

curl -X POST https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent \
  -H "x-goog-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {"text": "解释一下冒泡排序算法。"}
        ]
      }
    ],
    "generationConfig": {
      "temperature": 0.7,
      "maxOutputTokens": 1024
    }
  }'

import google.generativeai as genai

genai.configure(
    api_key="YOUR_API_KEY",
    transport="rest",
    client_options={"api_endpoint": "https://www.qingbo.dev/v1"}
)

model = genai.GenerativeModel("gemini-2.5-flash")

response = model.generate_content(
    "解释一下冒泡排序算法。",
    generation_config={
        "temperature": 0.7,
        "max_output_tokens": 1024
    }
)

print(response.text)

import { GoogleGenerativeAI } from '@google/generative-ai';

const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
const model = genAI.getGenerativeModel({
  model: 'gemini-2.5-flash',
  baseUrl: 'https://www.qingbo.dev/v1'
});

const result = await model.generateContent({
  contents: [{
    role: 'user',
    parts: [{ text: '解释一下冒泡排序算法。' }]
  }],
  generationConfig: {
    temperature: 0.7,
    maxOutputTokens: 1024
  }
});

console.log(result.response.text());

package main

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

func main() {
    payload := map[string]interface{}{
        "contents": []map[string]interface{}{
            {
                "role": "user",
                "parts": []map[string]string{
                    {"text": "解释一下冒泡排序算法。"},
                },
            },
        },
        "generationConfig": map[string]interface{}{
            "temperature":    0.7,
            "maxOutputTokens": 1024,
        },
    }

    body, _ := json.Marshal(payload)
    url := "https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent"
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
    req.Header.Set("x-goog-api-key", "YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    result, _ := io.ReadAll(resp.Body)
    fmt.Println(string(result))
}

import java.net.http.*;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String payload = """
        {
          "contents": [
            {
              "role": "user",
              "parts": [{"text": "解释一下冒泡排序算法。"}]
            }
          ],
          "generationConfig": {
            "temperature": 0.7,
            "maxOutputTokens": 1024
          }
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent"))
            .header("x-goog-api-key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

Overview

Supported Models

Gemini 3.1 Pro Preview

Latest-generation preview

Gemini 3 Flash Preview

Next-generation fast variant

Gemini 2.5 Pro

Pro tier, strong reasoning

Gemini 2.5 Flash

Fast tier, balanced speed and performance

Gemini 2.5 Flash Lite

Ultra-light, lowest latency

Request Parameters

string

required

Model ID, used as a URL path parameter:

gemini-3.1-pro-preview
gemini-3-flash-preview
gemini-2.5-pro
gemini-2.5-flash
gemini-2.5-flash-lite

array

required

Conversation contents array.

Show Content object

string

Role: user or model.

array

Array of content parts (text, images, etc.).

object

Generation configuration.

Show Configuration options

number

Sampling temperature, range 0–2.

integer

Maximum output tokens.

number

Nucleus sampling parameter.

integer

Top-K sampling parameter.

Request Example

curl https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: YOUR_API_KEY" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "解释量子计算的基本原理"
          }
        ]
      }
    ],
    "generationConfig": {
      "temperature": 0.7,
      "maxOutputTokens": 1000,
      "topP": 0.95
    }
  }'

import google.generativeai as genai

genai.configure(
    api_key="YOUR_API_KEY",
    transport="rest",
    client_options={"api_endpoint": "https://www.qingbo.dev/v1"}
)

model = genai.GenerativeModel('gemini-2.5-flash')

response = model.generate_content(
    "解释量子计算的基本原理",
    generation_config={
        "temperature": 0.7,
        "max_output_tokens": 1000,
        "top_p": 0.95
    }
)

print(response.text)

import { GoogleGenerativeAI } from '@google/generative-ai';

const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
const model = genAI.getGenerativeModel({ 
  model: 'gemini-2.5-flash',
  baseUrl: 'https://www.qingbo.dev/v1'
});

const result = await model.generateContent({
  contents: [{
    role: 'user',
    parts: [{ text: '解释量子计算的基本原理' }]
  }],
  generationConfig: {
    temperature: 0.7,
    maxOutputTokens: 1000,
    topP: 0.95
  }
});

console.log(result.response.text());

Response Format

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "量子计算是一种利用量子力学原理..."
          }
        ]
      },
      "finishReason": "STOP",
      "safetyRatings": [...]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 12,
    "candidatesTokenCount": 156,
    "totalTokenCount": 168
  }
}

Multimodal Input

Gemini supports mixed text and image input:

import PIL.Image

# Load image
img = PIL.Image.open('image.jpg')

# Send text and image
response = model.generate_content([
    "描述这张图片中的内容",
    img
])

print(response.text)

// Use a base64-encoded image
const result = await model.generateContent({
  contents: [{
    role: 'user',
    parts: [
      { text: '描述这张图片中的内容' },
      {
        inlineData: {
          mimeType: 'image/jpeg',
          data: base64ImageData
        }
      }
    ]
  }]
});

Streaming Output

response = model.generate_content(
    "写一个关于AI的故事",
    stream=True
)

for chunk in response:
    print(chunk.text, end="")

Safety Settings

Control the content filtering level:

from google.generativeai.types import HarmCategory, HarmBlockThreshold

response = model.generate_content(
    "你的提示词",
    safety_settings={
        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    }
)

Feature Comparison

Feature	Gemini 3.1 Pro	Gemini 3 Flash	Gemini 2.5 Pro	Gemini 2.5 Flash	Gemini 2.5 Flash Lite
Context window	1M tokens	1M tokens	1M tokens	1M tokens	1M tokens
Multimodal input	Yes	Yes	Yes	Yes	Yes
Code generation	Yes	Yes	Yes	Yes	Yes
Speed	Fast	Very fast	Fast	Very fast	Very fast

curl -X POST https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent \
  -H "x-goog-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {
        "role": "user",
        "parts": [
          {"text": "解释一下冒泡排序算法。"}
        ]
      }
    ],
    "generationConfig": {
      "temperature": 0.7,
      "maxOutputTokens": 1024
    }
  }'

import google.generativeai as genai

genai.configure(
    api_key="YOUR_API_KEY",
    transport="rest",
    client_options={"api_endpoint": "https://www.qingbo.dev/v1"}
)

model = genai.GenerativeModel("gemini-2.5-flash")

response = model.generate_content(
    "解释一下冒泡排序算法。",
    generation_config={
        "temperature": 0.7,
        "max_output_tokens": 1024
    }
)

print(response.text)

import { GoogleGenerativeAI } from '@google/generative-ai';

const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
const model = genAI.getGenerativeModel({
  model: 'gemini-2.5-flash',
  baseUrl: 'https://www.qingbo.dev/v1'
});

const result = await model.generateContent({
  contents: [{
    role: 'user',
    parts: [{ text: '解释一下冒泡排序算法。' }]
  }],
  generationConfig: {
    temperature: 0.7,
    maxOutputTokens: 1024
  }
});

console.log(result.response.text());

package main

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

func main() {
    payload := map[string]interface{}{
        "contents": []map[string]interface{}{
            {
                "role": "user",
                "parts": []map[string]string{
                    {"text": "解释一下冒泡排序算法。"},
                },
            },
        },
        "generationConfig": map[string]interface{}{
            "temperature":    0.7,
            "maxOutputTokens": 1024,
        },
    }

    body, _ := json.Marshal(payload)
    url := "https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent"
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
    req.Header.Set("x-goog-api-key", "YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    result, _ := io.ReadAll(resp.Body)
    fmt.Println(string(result))
}

import java.net.http.*;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String payload = """
        {
          "contents": [
            {
              "role": "user",
              "parts": [{"text": "解释一下冒泡排序算法。"}]
            }
          ],
          "generationConfig": {
            "temperature": 0.7,
            "maxOutputTokens": 1024
          }
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://www.qingbo.dev/v1/models/gemini-2.5-flash:generateContent"))
            .header("x-goog-api-key", "YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

Text Generation

Image Generation

Video Generation

Audio

Tools & Embeddings

Task Management

Gemini Native Format

Overview

Supported Models

Gemini 3.1 Pro Preview

Gemini 3 Flash Preview

Gemini 2.5 Pro

Gemini 2.5 Flash

Gemini 2.5 Flash Lite

Request Parameters

Request Example

Response Format

Multimodal Input

Streaming Output

Safety Settings

Feature Comparison

​Overview

​Supported Models

Gemini 3.1 Pro Preview

Gemini 3 Flash Preview

Gemini 2.5 Pro

Gemini 2.5 Flash

Gemini 2.5 Flash Lite

​Request Parameters

​Request Example

​Response Format

​Multimodal Input

​Streaming Output

​Safety Settings

​Feature Comparison

Overview

Supported Models

Request Parameters

Request Example

Response Format

Multimodal Input

Streaming Output

Safety Settings

Feature Comparison