Jetonları anlama ve sayma

Gemini ve diğer üretken yapay zeka modelleri, giriş ve çıkışları parça adı verilen bir ayrıntı düzeyinde işler.

Gemini modellerinde bir parça yaklaşık 4 karaktere eşdeğerdir. 100 jeton yaklaşık 60-80 İngilizce kelimeye eşittir.

Jetonlar hakkında

Jetonlar, z gibi tek karakterler veya cat gibi tam kelimeler olabilir. Uzun kelimeler birkaç parçaya bölünür. Model tarafından kullanılan tüm jetonların kümesine sözlük, metni jetonlara bölme işlemine ise jetonlara ayırma denir.

Faturalandırma etkinleştirildiğinde Gemini API'ye yapılan bir çağrının maliyeti kısmen giriş ve çıkış jetonlarının sayısına göre belirlenir. Bu nedenle, jetonların nasıl sayılacağını bilmek faydalı olabilir.

Colab'imizde jeton saymayı deneyebilirsiniz.

ai.google.dev'de görüntüle Colab not defterini deneyin Not defterini GitHub'da görüntüleme

Parça sayma

Gemini API'ye yapılan tüm girişler ve API'den alınan tüm çıkışlar (metin, resim dosyaları ve diğer metin dışı modaliteler dahil) parçalara ayrılır.

Jetonları aşağıdaki yöntemlerle sayabilirsiniz:

  • İsteğin girişiyle count_tokens işlevini çağırın.
    Bu, yalnızca girişteki toplam parça sayısını döndürür. İsteklerinizin boyutunu kontrol etmek için girişi modele göndermeden önce bu aramayı yapabilirsiniz.

  • generate_content işlevini çağırdıktan sonra response nesnesinde usage_metadata özelliğini kullanın.
    Bu işlev, hem girişteki hem de çıkıştaki toplam parça sayısını döndürür: total_token_count.
    Ayrıca giriş ve çıkışın jeton sayılarını ayrı ayrı döndürür:prompt_token_count (giriş jetonları) ve candidates_token_count (çıkış jetonları).

    Düşünen model kullanıyorsanız düşünme sürecinde kullanılan parçalar thoughts_token_count içinde döndürülür. Bağlam önbelleğe alma özelliğini kullanıyorsanız önbelleğe alınan jeton sayısı cached_content_token_count içinde gösterilir.

Metin jetonlarını sayma

count_tokens yöntemini yalnızca metin girişiyle çağırırsanız yalnızca girişteki (total_tokens) metnin parça sayısını döndürür. İsteklerinizin boyutunu kontrol etmek için generate_content yöntemini çağırmadan önce bu çağrıyı yapabilirsiniz.

Diğer bir seçenek de generate_content yöntemini çağırıp response nesnesindeki usage_metadata özelliğini kullanarak aşağıdakileri elde etmektir:

  • Giriş (prompt_token_count), önbelleğe alınmış içerik (cached_content_token_count) ve çıkışın (candidates_token_count) ayrı jeton sayıları
  • Düşünme süreci için jeton sayısı (thoughts_token_count)

  • Hem girişte hem de çıkışta toplam jeton sayısı (total_token_count)

Python

from google import genai

client = genai.Client()
prompt = "The quick brown fox jumps over the lazy dog."

total_tokens = client.models.count_tokens(
    model="gemini-3.8-flash", contents=prompt
)
print("total_tokens: ", total_tokens)

response = client.models.generate_content(
    model="gemini-3.8-flash", contents=prompt
)

print(response.usage_metadata)

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});
const prompt = "The quick brown fox jumps over the lazy dog.";

async function main() {
  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3.8-flash",
    contents: prompt,
  });
  console.log(countTokensResponse.totalTokens);

  const generateResponse = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: prompt,
  });
  console.log(generateResponse.usageMetadata);
}

await main();

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

// Convert prompt to a slice of *genai.Content using the helper.
contents := []*genai.Content{
  genai.NewContentFromText(prompt, genai.RoleUser),
}
countResp, err := client.Models.CountTokens(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
  return err
}
fmt.Println("total_tokens:", countResp.TotalTokens)

response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))
    ```

Çok aşamalı etkileşim (sohbet) parçalarını sayma

Sohbet geçmişiyle birlikte count_tokens işlevini çağırdığınızda, sohbetteki her rolden gelen metnin toplam jeton sayısını (total_tokens) döndürür.

Diğer bir seçenek de send_message yöntemini çağırıp response nesnesindeki usage_metadata özelliğini kullanarak aşağıdakileri elde etmektir:

  • Girişin (prompt_token_count), önbelleğe alınan içeriğin (cached_content_token_count) ve çıkışın (candidates_token_count) ayrı ayrı parça sayıları
  • Düşünme süreci için jeton sayısı (thoughts_token_count)
  • Hem girişte hem de çıkışta toplam jeton sayısı (total_token_count)

Bir sonraki etkileşiminizin ne kadar büyük olacağını anlamak için count_tokens işlevini çağırdığınızda bunu geçmişe eklemeniz gerekir.

Python

from google import genai
from google.genai import types

client = genai.Client()

chat = client.chats.create(
    model="gemini-3.8-flash",
    history=[
        types.Content(
            role="user", parts=[types.Part(text="Hi my name is Bob")]
        ),
        types.Content(role="model", parts=[types.Part(text="Hi Bob!")]),
    ],
)

print(
    client.models.count_tokens(
        model="gemini-3.8-flash", contents=chat.get_history()
    )
)

response = chat.send_message(
    message="In one sentence, explain how a computer works to a young child."
)
print(response.usage_metadata)

extra = types.UserContent(
    parts=[
        types.Part(
            text="What is the meaning of life?",
        )
    ]
)
history = [*chat.get_history(), extra]
print(client.models.count_tokens(model="gemini-3.8-flash", contents=history))

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function main() {
  const history = [
    { role: "user", parts: [{ text: "Hi my name is Bob" }] },
    { role: "model", parts: [{ text: "Hi Bob!" }] },
  ];
  const chat = ai.chats.create({
    model: "gemini-3.8-flash",
    history: history,
  });

  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3.8-flash",
    contents: chat.getHistory(),
  });
  console.log(countTokensResponse.totalTokens);

  const chatResponse = await chat.sendMessage({
    message: "In one sentence, explain how a computer works to a young child.",
  });
  console.log(chatResponse.usageMetadata);

  const extraMessage = {
    role: "user",
    parts: [{ text: "What is the meaning of life?" }],
  };
  const combinedHistory = [...chat.getHistory(), extraMessage];
  const combinedCountTokensResponse = await ai.models.countTokens({
    model: "gemini-3.8-flash",
    contents: combinedHistory,
  });
  console.log(
    "Combined history token count:",
    combinedCountTokensResponse.totalTokens,
  );
}

await main();

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

history := []*genai.Content{
  {Role: genai.RoleUser, Parts: []*genai.Part({Text: "Hi my name is Bob"})},
  {Role: genai.RoleModel, Parts: []*genai.Part({Text: "Hi Bob!"})},
}
chat, err := client.Chats.Create(ctx, "gemini-3.8-flash", nil, history)
if err != nil {
  log.Fatal(err)
}

firstTokenResp, err := client.Models.CountTokens(ctx, "gemini-3.8-flash", chat.History(false), nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println(firstTokenResp.TotalTokens)

resp, err := chat.SendMessage(ctx, genai.NewPartFromText("In one sentence, explain how a computer works to a young child."))
if err != nil {
  log.Fatal(err)
}
fmt.Printf("%#v\n", resp.UsageMetadata)

extra := genai.NewContentFromText("What is the meaning of life?", genai.RoleUser)
hist := chat.History(false)
hist = append(hist, extra)

secondTokenResp, err := client.Models.CountTokens(ctx, "gemini-3.8-flash", hist, nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println(secondTokenResp.TotalTokens)

Çok formatlı jetonları sayma

Gemini API'ye yapılan tüm girişler (metin, resim dosyaları ve diğer metin dışı biçimler dahil) jetonlaştırılır. Gemini API tarafından işleme sırasında çok formatlı girişin jetonlaştırılmasıyla ilgili aşağıdaki üst düzey önemli noktalara dikkat edin:

  • Her iki boyutu da <=384 piksel olan resim girişleri 258 jeton olarak sayılır. Bir veya her iki boyutta daha büyük olan resimler, gerektiğinde 768x768 piksellik parçalara kırpılır ve ölçeklendirilir. Her parça 258 jeton olarak sayılır.

  • Video ve ses dosyaları, şu sabit oranlarda jetonlara dönüştürülür: Video saniyede 263 jeton, ses ise saniyede 32 jeton. Bu ücret, statik işleme (varsayılan) için geçerlidir. Ajanlı işlemde jeton kullanımı değişir. İşleme moduna göre video jetonu kullanımı bölümünü inceleyin.

Medya çözünürlükleri

Gemini 3 modelleri, media_resolution parametresiyle çok formatlı görüntü işleme üzerinde ayrıntılı kontrol sağlar. media_resolution parametresi, giriş resim veya video karesi başına ayrılan maksimum jeton sayısını belirler. Daha yüksek çözünürlükler, modelin küçük metinleri okuma veya küçük ayrıntıları tanımlama yeteneğini artırır ancak jeton kullanımını ve gecikmeyi artırır.

Parametre ve jeton hesaplamalarını nasıl etkileyebileceği hakkında daha fazla bilgi için medya çözünürlüğü kılavuzunu inceleyin.

Resim dosyaları

count_tokens işlevini metin ve resim girişiyle çağırırsanız yalnızca girişteki (total_tokens) metin ve resmin birleştirilmiş jeton sayısını döndürür. İsteklerinizin boyutunu kontrol etmek için generate_content işlevini çağırmadan önce bu çağrıyı yapabilirsiniz. İsterseniz metni ve dosyayı ayrı ayrı count_tokens da çağırabilirsiniz.

Diğer bir seçenek de generate_content yöntemini çağırıp response nesnesindeki usage_metadata özelliğini kullanarak aşağıdakileri elde etmektir:

  • Giriş (prompt_token_count), önbelleğe alınmış içerik (cached_content_token_count) ve çıkışın (candidates_token_count) ayrı jeton sayıları
  • Düşünme süreci için jeton sayısı (thoughts_token_count)
  • Hem girişte hem de çıkışta toplam jeton sayısı (total_token_count)

File API'den yüklenen bir görüntüyü kullanan örnek:

Python

from google import genai

client = genai.Client()
prompt = "Tell me about this image"
your_image_file = client.files.upload(file=media / "organ.jpg")

print(
    client.models.count_tokens(
        model="gemini-3.8-flash", contents=[prompt, your_image_file]
    )
)

response = client.models.generate_content(
    model="gemini-3.8-flash", contents=[prompt, your_image_file]
)
print(response.usage_metadata)

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});
const prompt = "Tell me about this image";

async function main() {
  const organ = await ai.files.upload({
    file: path.join(media, "organ.jpg"),
    config: { mimeType: "image/jpeg" },
  });

  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3.8-flash",
    contents: createUserContent([
      prompt,
      createPartFromUri(organ.uri, organ.mimeType),
    ]),
  });
  console.log(countTokensResponse.totalTokens);

  const generateResponse = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: createUserContent([
      prompt,
      createPartFromUri(organ.uri, organ.mimeType),
    ]),
  });
  console.log(generateResponse.usageMetadata);
}

await main();

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

file, err := client.Files.UploadFromPath(
  ctx, 
  filepath.Join(getMedia(), "organ.jpg"), 
  &genai.UploadFileConfig{
    MIMEType : "image/jpeg",
  },
)
if err != nil {
  log.Fatal(err)
}
parts := []*genai.Part{
  genai.NewPartFromText("Tell me about this image"),
  genai.NewPartFromURI(file.URI, file.MIMEType),
}
contents := []*genai.Content{
  genai.NewContentFromParts(parts, genai.RoleUser),
}

tokenResp, err := client.Models.CountTokens(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println("Multimodal image token count:", tokenResp.TotalTokens)

response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))

Resmi satır içi veri olarak sağlayan örnek:

Python

from google import genai
import PIL.Image

client = genai.Client()
prompt = "Tell me about this image"
your_image_file = PIL.Image.open(media / "organ.jpg")

print(
    client.models.count_tokens(
        model="gemini-3.8-flash", contents=[prompt, your_image_file]
    )
)

response = client.models.generate_content(
    model="gemini-3.8-flash", contents=[prompt, your_image_file]
)
print(response.usage_metadata)

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});
const prompt = "Tell me about this image";
const imageBuffer = fs.readFileSync(path.join(media, "organ.jpg"));

const imageBase64 = imageBuffer.toString("base64");

const contents = createUserContent([
  prompt,
  createPartFromBase64(imageBase64, "image/jpeg"),
]);

async function main() {
  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3.8-flash",
    contents: contents,
  });
  console.log(countTokensResponse.totalTokens);

  const generateResponse = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: contents,
  });
  console.log(generateResponse.usageMetadata);
}

await main();

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

imageBytes, err := os.ReadFile("organ.jpg")
if err != nil {
    log.Fatalf("Failed to read image file: %v", err)
}
parts := []*genai.Part{
  genai.NewPartFromText("Tell me about this image"),
  {
        InlineData: &genai.Blob{
              MIMEType: "image/jpeg",
              Data:     imageBytes,
        },
  },
}
contents := []*genai.Content{
  genai.NewContentFromParts(parts, genai.RoleUser),
}

tokenResp, err := client.Models.CountTokens(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println("Multimodal image token count:", tokenResp.TotalTokens)

response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))

Video veya ses dosyaları

Ses ve video, aşağıdaki sabit oranlarda jetonlara dönüştürülür:

  • Video: Saniyede 263 jeton
  • Ses: Saniyede 32 jeton

count_tokens yöntemini metin ve video/ses girişiyle çağırırsanız yalnızca girişteki (total_tokens) metnin ve video/ses dosyasının birleştirilmiş token sayısını döndürür. İsteklerinizin boyutunu kontrol etmek için generate_content yöntemini çağırmadan önce bu çağrıyı yapabilirsiniz. İsterseniz metin ve dosya için count_tokens yöntemini ayrı ayrı da çağırabilirsiniz.

Diğer bir seçenek de generate_content yöntemini çağırıp response nesnesindeki usage_metadata özelliğini kullanarak aşağıdakileri elde etmektir:

  • Giriş (prompt_token_count), önbelleğe alınmış içerik (cached_content_token_count) ve çıkışın (candidates_token_count) ayrı jeton sayıları
  • Düşünme süreci için token sayısı (thoughts_token_count)

  • Hem giriş hem de çıkıştaki toplam parça sayısı (total_token_count).

Python

from google import genai
import time

client = genai.Client()
prompt = "Tell me about this video"
your_file = client.files.upload(file=media / "Big_Buck_Bunny.mp4")

while not your_file.state or your_file.state.name != "ACTIVE":
    print("Processing video...")
    print("File state:", your_file.state)
    time.sleep(5)
    your_file = client.files.get(name=your_file.name)

print(
    client.models.count_tokens(
        model="gemini-3.8-flash", contents=[prompt, your_file]
    )
)

response = client.models.generate_content(
    model="gemini-3.8-flash", contents=[prompt, your_file]
)
print(response.usage_metadata)

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});
const prompt = "Tell me about this video";

async function main() {
  let videoFile = await ai.files.upload({
    file: path.join(media, "Big_Buck_Bunny.mp4"),
    config: { mimeType: "video/mp4" },
  });

  while (!videoFile.state || videoFile.state.toString() !== "ACTIVE") {
    console.log("Processing video...");
    console.log("File state: ", videoFile.state);
    await sleep(5000);
    videoFile = await ai.files.get({ name: videoFile.name });
  }

  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3.8-flash",
    contents: createUserContent([
      prompt,
      createPartFromUri(videoFile.uri, videoFile.mimeType),
    ]),
  });
  console.log(countTokensResponse.totalTokens);

  const generateResponse = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: createUserContent([
      prompt,
      createPartFromUri(videoFile.uri, videoFile.mimeType),
    ]),
  });
  console.log(generateResponse.usageMetadata);
}

await main();

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

file, err := client.Files.UploadFromPath(
  ctx,
  filepath.Join(getMedia(), "Big_Buck_Bunny.mp4"),
  &genai.UploadFileConfig{
    MIMEType : "video/mp4",
  },
)
if err != nil {
  log.Fatal(err)
}

for file.State == genai.FileStateUnspecified || file.State != genai.FileStateActive {
  fmt.Println("Processing video...")
  fmt.Println("File state:", file.State)
  time.Sleep(5 * time.Second)

  file, err = client.Files.Get(ctx, file.Name, nil)
  if err != nil {
    log.Fatal(err)
  }
}

parts := []*genai.Part{
  genai.NewPartFromText("Tell me about this video"),
  genai.NewPartFromURI(file.URI, file.MIMEType),
}
contents := []*genai.Content{
  genai.NewContentFromParts(parts, genai.RoleUser),
}

tokenResp, err := client.Models.CountTokens(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println("Multimodal video/audio token count:", tokenResp.TotalTokens)
response, err := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))

İşleme moduna göre video jetonu kullanımı

Video için jeton kullanımı, işleme moduna bağlıdır:

İşleme modu Jeton hesaplama Tipik kullanım
Statik (varsayılan) Varsayılan olarak saniyede yaklaşık 100 jeton (düşük çözünürlük) veya saniyede yaklaşık 300 jeton (yüksek çözünürlük). Tüm kareler 1 FPS'de örneklenir. Tahmin edilebilir, video süresiyle orantılıdır.
Temsilci tabanlı çözümler İçeriğin karmaşıklığına göre değişir. Model, yalnızca istemi yanıtlamak için gereken transkripti ve/veya kareleri ve/veya sesi yükler. Uzun içeriklerde% 88'e kadar daha az jeton kullanılır.

Etkileşimli işleme ile, statik modda yaklaşık 1,08 milyon jeton kullanacak 1 saatlik bir ders, isteme ve içeriğe bağlı olarak yaklaşık 108 bin jeton kullanabilir.

Bir istek için gerçek jeton kullanımını kontrol etmek istiyorsanız yanıttaki usage_metadata alanını kullanın. UsageMetadata içinde, ajan tabanlı video jetonları aşağıdaki alanlarda raporlanır:

  • İlk istem (video referansı + kullanıcı istemi): prompt_token_count
  • Gezinme düşüncesi: thoughts_token_count
  • Transkript, kareler ve ses isteğe bağlı olarak yüklenir: tool_use_prompt_token_count
  • Son yanıt: candidates_token_count

Düşünce token'larını sayma

Düşünme özelliğini etkinleştirdiğinizde yanıt fiyatı, çıkış jetonları ile düşünme jetonlarının toplamı olur. Oluşturulan düşünme token'larının toplam sayısını thoughtsTokenCount alanından (veya SDK'daki eşdeğerinden) alabilirsiniz.

Python

# ...
print("Thoughts tokens:", response.usage_metadata.thoughts_token_count)
print("Output tokens:", response.usage_metadata.candidates_token_count)

JavaScript

// ...
console.log(`Thoughts tokens: ${response.usageMetadata.thoughtsTokenCount}`);
console.log(`Output tokens: ${response.usageMetadata.candidatesTokenCount}`);

Go

// ...
fmt.Println("Thoughts tokens:", response.UsageMetadata.ThoughtsTokenCount)
fmt.Println("Output tokens:", response.UsageMetadata.CandidatesTokenCount)

Düşünme modelleri, nihai yanıtın kalitesini artırmak için tam düşünceler üretir ve ardından düşünce süreci hakkında bilgi vermek için özetler oluşturur. Bu nedenle API, yalnızca özeti çıkarsa da fiyatlandırmayı, modelin özet oluşturmak için ürettiği tüm düşünce jetonlarına göre yapar.

Düşünme özelliğini nasıl yapılandıracağınız hakkında daha fazla bilgiyi Gemini'da düşünme kılavuzunda bulabilirsiniz.

Bağlam pencereleri

Gemini API üzerinden erişilebilen modellerin bağlam pencereleri jetonlarla ölçülür. Bağlam penceresi, ne kadar giriş sağlayabileceğinizi ve modelin ne kadar çıkış üretebileceğini tanımlar. Bağlam penceresinin boyutunu, models.get uç noktasını çağırarak veya modellerle ilgili belgelere bakarak belirleyebilirsiniz.

  • Gemini 4 modelleri (gemini-4-argon): Giriş, düşünme ve çıkış jetonları arasında tek bir 1 milyon jetonluk bağlam penceresini (1,048,576 jeton) paylaşır. Tekli istekler, akış için 65,536 çıkış jetonu (streamGenerateContent) ve akış dışı için 32,768 çıkış jetonu (generateContent) ile sınırlandırılır. Alternatif olarak, uzun kod çözme kullanarak 1,048,576 jetona kadar oluşturabilirsiniz. Giriş jetonlarınız ile max_output_tokens toplamı 1.048.576 jetonu aşarsa API, çıkış sınırını otomatik olarak bağlam penceresindeki kalan alanla (1,048,576 eksi giriş jetonlarınız) sınırlandırır.

  • Gemini 3 ve 2.5 modelleri: Giriş (1,048,576 jeton) ve çıkış (65,536 jeton) için ayrı bütçeler kullanın.

Python

from google import genai

client = genai.Client()
model_info = client.models.get(model="gemini-3.8-flash")
print(f"{model_info.input_token_limit=}")
print(f"{model_info.output_token_limit=}")

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function main() {
  const modelInfo = await ai.models.get({model: 'gemini-3.8-flash'});
  console.log(modelInfo.inputTokenLimit);
  console.log(modelInfo.outputTokenLimit);
}

await main();

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
  log.Fatal(err)
}
modelInfo, err := client.ModelInfo(ctx, "models/gemini-3.8-flash")
if err != nil {
  log.Fatal(err)
}
fmt.Println("input token limit:", modelInfo.InputTokenLimit)
fmt.Println("output token limit:", modelInfo.OutputTokenLimit)