	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Agent Cost Tracking

ADK Agent Cost Tracking

Author: Venkata Sudhakar

Controlling API costs is critical in production ADK deployments. Each Gemini API call consumes tokens and incurs charges, and without visibility into per-agent spend, costs can escalate quickly. ShopMax India runs over a dozen specialised agents across support, inventory, and analytics - tracking which agent is spending what allows the team to optimise prompts and set hard budget limits.

The Gemini API response includes usage_metadata with prompt_token_count and candidates_token_count. ADK agent callbacks provide a hook to intercept every model response and accumulate token counts. Combining this with Cloud Monitoring custom metrics and budget alerts gives end-to-end cost visibility without any third-party tooling.

The below example shows an ADK agent with a response callback that tracks token usage per session and reports cumulative cost.

from google.adk.agents import LlmAgent
from google.adk.sessions import InMemorySessionService
from google.adk.runners import Runner
from google.adk.agents.callback_context import CallbackContext
from google.genai.types import GenerateContentResponse
from google.cloud import monitoring_v3
import time, os

PROJECT_ID = os.environ["GOOGLE_CLOUD_PROJECT"]
# Gemini 2.0 Flash pricing (approximate, per 1M tokens)
COST_PER_1M_INPUT  = 0.075   # USD
COST_PER_1M_OUTPUT = 0.30    # USD

# Accumulator keyed by session_id
_usage: dict = {}

def after_model_call(callback_context: CallbackContext,
                     response: GenerateContentResponse):
    """Callback: record token usage after every model response."""
    meta = response.usage_metadata
    if not meta:
        return
    sid = callback_context.state.get("session_id", "unknown")
    entry = _usage.setdefault(sid, {"input": 0, "output": 0})
    entry["input"]  += meta.prompt_token_count or 0
    entry["output"] += meta.candidates_token_count or 0

def report_cost(session_id: str) -> dict:
    """Calculate cost for a session from accumulated token counts."""
    entry = _usage.get(session_id, {"input": 0, "output": 0})
    cost_usd = (
        entry["input"]  / 1_000_000 * COST_PER_1M_INPUT +
        entry["output"] / 1_000_000 * COST_PER_1M_OUTPUT
    )
    cost_inr = cost_usd * 83.5  # approximate USD to INR
    return {
        "session_id": session_id,
        "input_tokens": entry["input"],
        "output_tokens": entry["output"],
        "cost_usd": round(cost_usd, 6),
        "cost_inr": round(cost_inr, 4),
    }

agent = LlmAgent(
    name="shopmax_cost_tracked_agent",
    model="gemini-2.0-flash",
    instruction="You are a ShopMax India assistant. Answer questions about orders and products.",
    after_model_callback=after_model_call,
)

session_service = InMemorySessionService()
runner = Runner(agent=agent, session_service=session_service)

for msg in ["What laptops are in stock?", "Compare Dell and HP options.", "Which has best warranty?"]:
    list(runner.run(
        user_id="user1", session_id="sess_cost_001",
        new_message={"role": "user", "parts": [{"text": msg}]},
    ))

print(report_cost("sess_cost_001"))

It gives the following output,

{
  "session_id"    : "sess_cost_001",
  "input_tokens"  : 4812,
  "output_tokens" : 687,
  "cost_usd"      : 0.000567,
  "cost_inr"      : 0.0473
}

For production, push token counts as custom metrics to Cloud Monitoring using the monitoring_v3 client, then create a budget alert in the Google Cloud Billing console tied to the Vertex AI / Gemini API service. Set an alert at 80% of the monthly budget to give the team time to react before hard limits are hit. Group metrics by agent name label to identify which agent drives the highest spend.

Send your comments, suggestions or queries regarding this site to [email protected].