Token / Cost / Usage Tracking with the new ADK (Using Python, not the Dashboard)?

[BrewHog]

Are there any built-in functions to determine cost / use of queries using the ADK? At the moment, I am using the free exp models (gemini-2.0-flash-exp). I need to understand what the costs/usage will be for my flows when put into production.

[osmariofilho]

yes. correct

[BrewHog]

yes. correct

? There is a function to track tokens/cost? Could you elaborate? Thanks

[thetushargoyal]

I have added support for cost in this PR for LiteLLM models. Check it out #198

[weisiang9678]

can you show an example ? i could not get the "usage_metadata" from the llm response.
The only to get the token usage is through LiteLLM ? For my use case, it does not require LiteLLM.
Thanks !

[Shivam-002]

I am also having same question. Looking into the code I didn't find any build-in methods. If anyone knows that how to do it please let us know.

[thetushargoyal]

I have added support for cost in this PR for LiteLLM models. Check it out #198

[Pavan-Bellam]

Has anyone figured out a solution for this?

[thetushargoyal]

I have added support for cost in this PR for LiteLLM models. Check it out #198

[beinoriusju]

LiteLlm has cost counters

[lsimone]

I had the same problem since I wanted to track some costs/usage stats, so I tried to intercept with after_model_callback but no luck.

I finally came up with something similar:

def track_llm_usage(res: ModelResponse | CustomStreamWrapper, model):
            # Log token usage and cost before returning
        try:
            usage = res.get("usage", {})
            prompt_tokens = usage.get("prompt_tokens", 0)
            completion_tokens = usage.get("completion_tokens", 0)
            total_tokens = usage.get("total_tokens", prompt_tokens + completion_tokens)
            
            # Calculate cost if possible
            cost = litellm.completion_cost(completion_response=res) or 0.0
            
            print(f"[acompletion] Model: {model}")
            print(f"[acompletion] Prompt tokens: {prompt_tokens}")
            print(f"[acompletion] Completion tokens: {completion_tokens}")
            print(f"[acompletion] Total tokens: {total_tokens}")
            print(f"[acompletion] Cost: ${cost:.6f}")
            print(f"[acompletion] Time: {(res._response_ms / 1000):.2f}s")
        except Exception as e:
            print(f"Error logging token usage: {e}")
        return res


class KLiteLLMClient(LiteLLMClient):
    async def acompletion(
      self, model, messages, tools, **kwargs
    ):
        return track_llm_usage(await super().acompletion(
            model=model,
            messages=messages,
            tools=tools,
            **kwargs,
        ), model=model)
        
 
    
 root_agent = LlmAgent(
    name="weather_time_agent",
    model=LiteLlm(model="gemini/gemini-2.5-flash-preview-04-17", 
        llm_client=KLiteLLMClient()
    ),
#    [...]
)

hope it helps!

[PaveLuchkov]

litellm._turn_on_debug()
you can paste this in your code, and it will show you following:

"usage":{"prompt_tokens":350,"completion_tokens":418,"total_tokens":768}}

search within terminal using ctrl f "total_tokens". hope that helps

[OhVIton]

If you are using LiteLlm as an agent model, add stream_options={"include_usage": True} to LiteLlm constructor

LiteLlm(
    'azure/gpt-4.1',
    stream_options={"include_usage": True}
)

and you can get usage tokens by Event.usage_metadata

        events = runner.run_async(
            session_id=session.id,
            user_id=session.user_id,
            new_message=self.__messages_to_agent_new_message(messages),
            run_config=RunConfig(streaming_mode=StreamingMode.SSE),
        )
    async for event in events:
        # cache_tokens_details=None cached_content_token_count=None candidates_token_count=None candidates_tokens_details=None prompt_token_count=172 prompt_tokens_details=[ModalityTokenCount(modality=<MediaModality.TEXT: 'TEXT'>, token_count=172)] thoughts_token_count=44 tool_use_prompt_token_count=None tool_use_prompt_tokens_details=None total_token_count=216 traffic_type=None
        print(event.usage_metadata)

[adityapandey216]

Does the response return output tokens? Having output tokens gives sense of better overall cost breakdown

[sarojrout]

Yes! ADK provides token tracking through event.usage_metadata. Here's a quick example:

async for event in runner.run_async(...):
    if event.usage_metadata:
        print(f"Tokens: {event.usage_metadata.total_token_count}")
        print(f"Prompt: {event.usage_metadata.prompt_token_count}")
        print(f"Candidates: {event.usage_metadata.candidates_token_count}")

See contributing/samples/token_usage/main.py for a complete example with cost calculation.

[adityapandey216]

@sarojrout is it safe to say total_output_tokens = candidates_token_count + thoughts_token_count ?

[sarojrout]

@sarojrout is it safe to say total_output_tokens = candidates_token_count + thoughts_token_count ?

yes

[sarojrout]

just to let you know thoughts_token_count is only available for models with reasoning capabilities (e.g., Gemini 2.0 Flash Thinking). For regular models, it's None or 0.

[0dd]

@adk-bot what is the current design?

[adk-bot]

Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: You can track token usage directly in Python by inspecting the usage_metadata events generated by the ADK Runner. This will give you prompt, candidate, and total token counts for each model call.

---

Hello! As an AI assistant, I can provide some information on how to track token and cost usage with the ADK in Python.

Built-in Usage Tracking

The ADK provides a built-in mechanism to track token usage for each call to a language model. When you use runner.run_live(), the runner emits usage_metadata events that contain token count information. You can inspect these events to get detailed usage data. [1]

Here is an example of how you can access this information in your Python code:

from google.adk.runtime import runner

# Your ADK setup and agent definition here...

if __name__ == "__main__":
    for event_type, event_data in runner.run_live(agent):
        if event_type == "usage_metadata":
            print(f"Token Usage: {event_data}")

The event_data for a usage_metadata event will look something like this:

{
    "prompt_token_count": 120,
    "candidates_token_count": 250,
    "total_token_count": 370
}

This allows you to programmatically track token usage without relying on the dashboard. You can then calculate the estimated cost based on the pricing of the models you are using.

Advanced Monitoring and Observability

For more advanced monitoring and analytics, you can explore the following options:

• ADK Plugins: You can create your own ADK Plugins to collect and export metrics on token usage and other agent behaviors to any monitoring system you prefer. [2, 3]
• BigQuery Agent Analytics Plugin: For high-volume analysis, the ADK offers a plugin to log detailed agent analytics to BigQuery. This allows you to run complex queries on your agent's behavior and performance. [5]
• Third-Party Integrations: The ADK also supports integration with third-party observability platforms like AgentOps for more comprehensive monitoring of cost, latency, and other metrics. [4]

I hope this helps you understand how to track your ADK usage and costs!

---

Footnotes:

[1] https://google.github.io/adk-docs/streaming/dev-guide/part3/
[2] https://github.com/google/adk-python/blob/main/contributing/samples/plugin_basic/README.md
[3] https://google.github.io/adk-docs/plugins/
[4] https://google.github.io/adk-docs/observability/agentops/
[5] https://google.github.io/adk-docs/tools/google-cloud/bigquery-agent-analytics/

[haiyuan-eng-google]

https://google.github.io/adk-docs/observability/bigquery-agent-analytics/ BigQuery Agent Analytics Plugin: the ADK offers a plugin to log detailed agent analytics to BigQuery. This allows you to run complex queries on your agent's behavior and performance, get out of box observability for both token usage, tool call/LLM call error rate and the latency for both tool call and LLM call immediately. The plugin just need one line code change to add plugin into your APP.

[gaurav-gandhi-2411]

Cost per invocation is tokens times the price of the model that served the call; the price lookup is where people get stuck.

adk-tracegauge does that lookup (disclosure: I maintain it). All 22 price-table entries carry a source URL and fetch date; 20 are re-checked against the vendor's page weekly, and report labels the other two unverifiable.

adk-tracegauge report: 3 invocation(s) (2 priced, 1 unknown) -- live run of mixed_run:run
  invocation      model(s)          calls  tokens in  tokens out  cost (USD)
  --------------  ----------------  -----  ---------  ----------  ----------
  e-e3861ac8-0f0  gemini-2.5-flash      1     12,000         800   $0.005600
  e-e8fad1df-eb9  gemini-2.5-flash      1      3,500         420   $0.002100
  e-387fdd7a-5d7  UNKNOWN               -          -           -     unknown

  priced total: $0.007700 across 2 invocation(s) -- EXCLUDES 1 unknown invocation(s), so the true total is at least this
  tokens (priced invocations): 15,500 in / 1,220 out

  Unknown invocations were NOT priced (no guessed rate is ever used):
  e-387fdd7a-5d7: model 'acme-llm-7b' is not in the price table (see README, 'Pricing')

By hand: 3,500 x $0.30/M + 420 x $2.50/M = $0.0021; $0.0056 + $0.0021 = $0.0077. Fake model, no API key.

Anything it cannot price is flagged, not guessed: unknown models, audio input, image/audio/video output, and Google Search grounding. The total states what it leaves out.

adk eval applies an App's plugins= from google-adk 2.7 (2.6: after_model_callback=); its cost metric needs adk-tracegauge[eval]. Cold install with pip: 79 s base (median of 3), 394 s with [eval].

[citw2]

Full disclosure: this is the SAIHM project's account.

You're hitting a real gap—the ADK gives you model calls, but tracking the actual token flow through a multi-step agent workflow is harder than it looks. By the time you're in production, you need to know not just per-call costs, but which memory reads and context re-feeds are inflating your bill.

SAIHM lets you measure this concretely: it logs every memory recall (which cells, how many tokens), so you can run your workflow against test data and see the token delta between "naive re-feed" and "selective recall." You own the logs; you can audit them. That gives you a real production cost estimate before you commit budget.

More on how that works: https://t.saihm.coti.global/r/gh-tokensave