Exploring the OpenAI API: Tokens, Costs, and Usage

import os
from IPython.display import display
import ipywidgets as widgets

try:
    from dotenv import load_dotenv
except:
    !pip install python-dotenv
    from dotenv import load_dotenv

try:
    from openai import OpenAI
except ImportError:
    !pip install openai
    from openai import OpenAI

# file path for the .env file containing the OpenAI API key
env_file_path = "/home/jovyan/shared/.env"
load_dotenv(env_file_path)

openai_api_key = os.getenv('OPENAI_API_KEY')
print("API Key loaded:", "✅" if openai_api_key else "❌ not found")

# this cell is just if you want to manually load a different API Key 
#openai_api_key =""

client = OpenAI(api_key = openai_api_key)

models = client.models.list()
print([m.id for m in models])

# Send a chat message to GPT-4o-mini
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a UC Berkeley Economics Student"},
        {"role": "user", "content": "Explain who pays the burden of tariffs"}
    ]
)

# Display response
print(response.choices[0].message.content)

# Define token prices (per 1K tokens)
# Prices approx. March 2026 — verify at https://openai.com/api/pricing/

token_prices = {
    "gpt-5": {"input": 0.00125, "output": 0.01000},
    "gpt-5-mini": {"input": 0.00025, "output": 0.00200},
    "gpt-5-nano": {"input": 0.00005, "output": 0.00040},

    "gpt-4.1": {"input": 0.00200, "output": 0.00800},
    "gpt-4.1-mini": {"input": 0.00040, "output": 0.00160},
    "gpt-4.1-nano": {"input": 0.00020, "output": 0.00080},

    "gpt-4o": {"input": 0.00250, "output": 0.01000},
    "gpt-4o-mini": {"input": 0.00015, "output": 0.00060},

    "o3-mini": {"input": 0.00110, "output": 0.00440},
}

# Widgets
model_selector = widgets.Dropdown(
    options=list(token_prices.keys()),
    value="gpt-4o-mini",
    description='Model:',)

input_tokens = widgets.IntText(
    value=10000,
    description='Input Tokens:',)

output_tokens = widgets.IntText(
    value=5000,
    description='Output Tokens:',)

estimate_button = widgets.Button(
    description="Estimate Cost",
    button_style="success")

cost_display = widgets.Label(value="")

# Define the estimator
def estimate_cost(b):
    model = model_selector.value
    input_count = input_tokens.value
    output_count = output_tokens.value
    prices = token_prices[model] 
    cost = (input_count / 1000) * prices["input"] + (output_count / 1000) * prices["output"]
    cost_display.value = f"💲 Estimated Cost: ${cost:.6f}"

estimate_button.on_click(estimate_cost)

# Display everything
display(model_selector, input_tokens, output_tokens, estimate_button, cost_display)

# Send a chat message to GPT-4o mini
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a UC Berkeley Economics Student"},
        {"role": "user", "content": "Explain who pays the burden of tariffs"}
    ]
)

# Display response
print(response.choices[0].message.content)

# Display token usage
print("\n🔢 Token Usage:")
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")
print(f"Total tokens: {response.usage.total_tokens}")

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": """
You are an advanced UC Berkeley undergraduate economics student enrolled in
Intermediate Macroeconomics and International Trade.

Your responses should:
• Use formal economic reasoning and terminology.
• Reference economic models such as supply and demand, partial equilibrium,
  and basic trade theory (e.g., incidence of tariffs, elasticity, welfare effects).
• Explain concepts clearly but at an intermediate level appropriate for
  a second-year economics major.
• Use structured explanations and occasionally reference diagrams conceptually
  (even though you cannot draw them).
• Distinguish between short-run and long-run effects when appropriate.
• Avoid political rhetoric and focus on economic analysis.

When relevant, discuss:
- Consumer surplus
- Producer surplus
- Deadweight loss
- Elasticity of supply and demand
- Terms of trade effects
- Distributional impacts across domestic consumers, domestic producers,
  and foreign exporters.

Respond in 2–3 well-structured paragraphs.
"""
        },
        {
            "role": "user",
            "content": """
Suppose the United States imposes a 25% tariff on imported steel. The policy
is justified politically as a way to protect domestic steel producers and
support domestic manufacturing employment.

Using standard economic theory, analyze who ultimately bears the burden of
this tariff.

In your answer, discuss:

• How the incidence of the tariff depends on the elasticity of supply and demand
  in the domestic and international markets.

• Whether domestic consumers, domestic producers, or foreign exporters bear
  the largest share of the burden.

• The effects on prices, consumer surplus, producer surplus, and government
  tariff revenue.

• Any deadweight losses generated by the tariff.

• How the analysis might differ in the short run versus the long run.

Assume the United States is a large enough country that its tariff can affect
world prices.
"""
        }
    ],
    temperature=0.7,
    top_p=1.0,
    presence_penalty=0.5,
    frequency_penalty=0.3,
    max_tokens=400,
    stop=None
)

# Display the response text
print("📘 Response:")
print(response.choices[0].message.content)

# Display token usage
print("\n🔢 Token Usage:")
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")
print(f"Total tokens: {response.usage.total_tokens}")

import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame(token_prices).T
df

# Example token usage scenarios
token_usage_scenarios = {
    "Small": {"input": 500, "output": 250},
    "Medium": {"input": 2000, "output": 1000},
    "Large": {"input": 10000, "output": 5000},
}

# Cost function
def estimate_cost(model, input_tokens, output_tokens):
    price = token_prices[model]
    return (input_tokens/1000)*price["input"] + (output_tokens/1000)*price["output"]

# Build table of results
cost_records = []

for scenario_name, tokens in token_usage_scenarios.items():
    for model_name in token_prices:
        cost = estimate_cost(model_name, tokens["input"], tokens["output"])
        cost_records.append({
            "scenario": scenario_name,
            "model": model_name,
            "cost": cost
        })

token_cost_table = pd.DataFrame(cost_records)

# Select one scenario for visualization
medium_usage_costs = token_cost_table[token_cost_table["scenario"] == "Medium"]

# Bar chart
plt.figure()
plt.bar(medium_usage_costs["model"], medium_usage_costs["cost"])
plt.xticks(rotation=45)
plt.ylabel("Estimated Cost ($)")
plt.title("Model Cost Comparison (Medium Token Usage)")
plt.show()