Tokens

Ya está disponible la versión preliminar de Gemini 3.1 Flash-Lite. Pruébalo en AI Studio.

Página principal

Gemini API

Documentos

Enviar comentarios

Comprender y contar tokens

Gemini y otros modelos de IA generativa procesan la entrada y la salida con una granularidad

llamada un token.

En el caso de los modelos de Gemini, un token equivale a aproximadamente 4 caracteres.

100 tokens equivalen a entre 60 y 80 palabras en inglés.

Acerca de los tokens

Los tokens pueden ser caracteres individuales, como z, o palabras completas, como cat. Las palabras largas

se dividen en varios tokens. El conjunto de todos los tokens que usa el modelo se

denomina vocabulario, y el proceso de dividir el texto en tokens se denomina

tokenización.

Cuando la facturación está habilitada, el costo de una llamada a la API de Gemini se

determina, en parte, por la cantidad de tokens de entrada y salida, por lo que puede ser útil saber cómo

contarlos.

Puedes probar el recuento de tokens en nuestro Colab.

Ver en ai.google.dev

Probar un notebook de Colab

Ver el notebook en GitHub

Cuenta tokens

Toda la entrada y la salida de la API de Gemini se tokenizan, incluido el texto, los archivos de imagen

y otras modalidades que no son de texto.

Puedes contar tokens de las siguientes maneras:

Llama a count_tokens con la entrada

de la solicitud.

Esto muestra la cantidad total de tokens solo en la entrada. Puedes realizar esta llamada antes de enviar la entrada al

modelo para verificar el tamaño de tus solicitudes.

Usa el atributo usage_metadata en el objeto response después de

llamar a generate_content.

Esto muestra la cantidad total de

tokens tanto en la entrada como en la salida: total_token_count.

También

muestra los recuentos de tokens de la entrada y la salida por separado:

prompt_token_count (tokens de entrada) y candidates_token_count

(tokens de salida).

Si usas un modelo

de pensamiento, el token que se usa durante el proceso de pensamiento se muestra en thoughts_token_count. Si usas el almacenamiento en caché de

contexto, el recuento de tokens

almacenados en caché estará en cached_content_token_count.

Cuenta tokens de texto

Si llamas a count_tokens con una entrada solo de texto, se muestra el recuento de tokens de

el texto solo en la entrada (total_tokens). Puedes realizar esta llamada antes de

llamar a generate_content para verificar el tamaño de tus solicitudes.

Otra opción es llamar a generate_content y, luego, usar el usage_metadata

atributo en el objeto response para obtener lo siguiente:

• Los recuentos de tokens separados de la entrada (prompt_token_count), el contenido almacenado en caché (cached_content_token_count) y la salida (candidates_token_count)

• El recuento de tokens para el proceso de pensamiento (thoughts_token_count)

La cantidad total de tokens en tanto en la entrada como en la salida

(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-flash-preview", contents=prompt
)
print("total_tokens: ", total_tokens)
response = client.models.generate_content(
    model="gemini-3-flash-preview", 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-flash-preview",
    contents: prompt,
  });
  console.log(countTokensResponse.totalTokens);
  const generateResponse = await ai.models.generateContent({
    model: "gemini-3-flash-preview",
    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-flash-preview", contents, nil)
if err != nil {
  return err
}
fmt.Println("total_tokens:", countResp.TotalTokens)
response, err := client.Models.GenerateContent(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))
    

Cuenta tokens de varios turnos (chat)
Si llamas a count_tokens con el historial de chat, se muestra el recuento total de tokens del texto de cada rol en el chat (total_tokens).
Otra opción es llamar a send_message y, luego, usar el atributo usage_metadata
en el objeto response para obtener lo siguiente:
Los recuentos de tokens separados de la entrada (prompt_token_count), el contenido almacenado en caché (cached_content_token_count) y la salida (candidates_token_count)

El recuento de tokens para el proceso de pensamiento (thoughts_token_count)

La cantidad total de tokens en tanto en la entrada como en la salida
(total_token_count)
Para comprender el tamaño de tu próximo turno conversacional, debes agregar
lo al historial cuando llames a count_tokens.
Python

from google import genai

from google.genai import types

client = genai.Client()

chat = client.chats.create(

model="gemini-3-flash-preview",

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-flash-preview", 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-flash-preview", 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-flash-preview",

history: history,

});

const countTokensResponse = await ai.models.countTokens({

model: "gemini-3-flash-preview",

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-flash-preview",

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-flash-preview", nil, history)

if err != nil {

log.Fatal(err)

}

firstTokenResp, err := client.Models.CountTokens(ctx, "gemini-3-flash-preview", 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-flash-preview", hist, nil)

if err != nil {

log.Fatal(err)

}

fmt.Println(secondTokenResp.TotalTokens)

```

Cuenta tokens multimodales

Toda la entrada a la API de Gemini se tokeniza, incluido el texto, los archivos de imagen y otras

modalidades que no son de texto. Ten en cuenta los siguientes puntos clave de alto nivel sobre la tokenización

de la entrada multimodal durante el procesamiento de la API de Gemini:

Las entradas de imágenes con ambas dimensiones <=384 píxeles se cuentan como

258 tokens. Las imágenes más grandes en un