​

View costs in the LangSmith UI

​

Token and cost breakdowns

• Input: Tokens in the prompt sent to the model. Subtypes include: cache reads, text tokens, image tokens, etc.
• Output: Tokens generated in the response from the model. Subtypes include: reasoning tokens, text tokens, image tokens, etc.
• Other: Costs from tool calls, retrieval steps, or any custom runs.

​

In the trace tree

​

In project stats

​

In dashboards

​

Cost tracking

1. Automatically: derived from token counts and model prices for LLM calls.
2. Manually: specified directly on any run, including non-LLM types.

​

LLM calls: Automatically track costs based on token counts

1. Send token counts. Many models include token counts as part of the response. You must extract this information and include it in your run using one of the following methods:
   • Set a usage_metadata field on the run’s metadata. The advantage of this approach is that you do not need to change your traced function’s runtime outputs:

     from langsmith import traceable, get_current_run_tree
     
     inputs = [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "I'd like to book a table for two."},
     ]
     
     @traceable(
      run_type="llm",
      metadata={"ls_provider": "my_provider", "ls_model_name": "my_model"}
     )
     def chat_model(messages: list):
      # Imagine this is the real model output format your application expects
      assistant_message = {
      "role": "assistant",
      "content": "Sure, what time would you like to book the table for?"
      }
     
      # Token usage you compute or receive from the provider
      token_usage = {
      "input_tokens": 27,
      "output_tokens": 13,
      "total_tokens": 40,
      "input_token_details": {"cache_read": 10}
      }
     
      # Attach token usage to the LangSmith run
      run = get_current_run_tree()
      run.set(usage_metadata=token_usage)
     
      return assistant_message
     
     chat_model(inputs)
     

     The Java and Kotlin examples use a dedicated executor. Shutting down the executor and awaiting termination ensures background trace submissions complete before the process exits.
   • Return a usage_metadata field in your traced function’s outputs. Include the usage_metadata key directly within the object returned by your traced function. LangSmith will extract it from the output:

     from langsmith import traceable
     
     inputs = [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "I'd like to book a table for two."},
     ]
     output = {
      "choices": [
      {
      "message": {
      "role": "assistant",
      "content": "Sure, what time would you like to book the table for?"
      }
      }
      ],
      "usage_metadata": {
      "input_tokens": 27,
      "output_tokens": 13,
      "total_tokens": 40,
      "input_token_details": {"cache_read": 10}
      },
     }
     
     @traceable(
      run_type="llm",
      metadata={"ls_provider": "my_provider", "ls_model_name": "my_model"}
     )
     def chat_model(messages: list):
      return output
     
     chat_model(inputs)
     

   In either case, the usage metadata should contain a subset of the following LangSmith-recognized fields:
2. Specify model name. When using a custom model, the following fields need to be specified in a run’s metadata in order to associate token counts with costs. It’s also helpful to provide these metadata fields to identify the model when viewing traces and when filtering.
   • ls_provider: The provider of the model, e.g., “openai”, “anthropic”
   • ls_model_name: The name of the model, e.g., “gpt-5.4-mini”, “claude-3-opus-20240229”
3. Set model prices. LangSmith maps model names to per-token prices using its model pricing table to compute costs from token counts.
   The table comes with pricing information for most OpenAI, Anthropic, and Gemini models. You can create a new model price entry or overwrite pricing for default models if you have custom pricing.
   For models that have different pricing for different token types (e.g., multimodal or cached tokens), you can specify a breakdown of prices for each token type. Hovering over the … next to the Input price and Output price entries shows you the price breakdown by token type.
   LangSmith does not reflect updates to the model pricing map in the costs for traces already logged. Backfilling model pricing changes is not supported.

​

Create a new or modify an existing model price entry

• Model Name: The human-readable name of the model.
• Input Price: The cost per 1M input tokens for the model. This number is multiplied by the number of tokens in the prompt to calculate the prompt cost.
• Input Price Breakdown (Optional): The breakdown of price for each different type of input token, e.g., cache_read, video, audio.
• Output Price: The cost per 1M output tokens for the model. This number is multiplied by the number of tokens in the completion to calculate the completion cost.
• Output Price Breakdown (Optional): The breakdown of price for each different type of output token, e.g., reasoning, image, etc.
• Model Activation Date (Optional): The date from which the pricing is applicable. Only runs after this date will apply this model price.
• Match Pattern: A regex pattern to match the model name. This is used to match the value for ls_model_name in the run metadata.
• Provider (Optional): The provider of the model. If specified, this is matched against ls_provider in the run metadata.

​

LLM calls: Send costs directly

from langsmith import traceable, get_current_run_tree

inputs = [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "I'd like to book a table for two."},
]

@traceable(
 run_type="llm",
 metadata={"ls_provider": "my_provider", "ls_model_name": "my_model"}
)
def chat_model(messages: list):
 llm_output = {
 "choices": [
 {
 "message": {
 "role": "assistant",
 "content": "Sure, what time would you like to book the table for?"
 }
 }
 ],
 "usage_metadata": {
 # Specify cost (in dollars) for the inputs and outputs
 "input_cost": 1.1e-6,
 "input_cost_details": {"cache_read": 2.3e-7},
 "output_cost": 5.0e-6,
 },
 }
 run = get_current_run_tree()
 run.set(usage_metadata=llm_output["usage_metadata"])
 return llm_output["choices"][0]["message"]

chat_model(inputs)

​

Other runs: Send costs

from langsmith import traceable, get_current_run_tree

# Example tool: get_weather
@traceable(run_type="tool", name="get_weather")
def get_weather(city: str):
 # Your tool logic goes here
 result = {
 "temperature_f": 68,
 "condition": "sunny",
 "city": city,
 }

 # Cost for this tool call (computed however you like)
 tool_cost = 0.0015

 # Attach usage metadata to the LangSmith run
 run = get_current_run_tree()
 run.set(usage_metadata={"total_cost": tool_cost})

 # Return only the actual tool result (no usage info)
 return result

tool_response = get_weather("San Francisco")

from langsmith import traceable

# Example tool: get_weather
@traceable(run_type="tool", name="get_weather")
def get_weather(city: str):
 # Your tool logic goes here
 result = {
 "temperature_f": 68,
 "condition": "sunny",
 "city": city,
 }

 # Attach tool call costs here
 return {
 **result,
 "usage_metadata": {
 "total_cost": 0.0015, # <-- cost for this tool call
 },
 }

tool_response = get_weather("San Francisco")