import streamlit as st import pandas as pd import plotly.express as px import plotly.graph_objects as go import numpy as np from datetime import datetime # Page configuration st.set_page_config( page_title="GPT-4o mini Pricing Calculator", page_icon="🤖", layout="wide", initial_sidebar_state="expanded" ) # Custom styling st.markdown(""" """, unsafe_allow_html=True) # Title section st.markdown('
', unsafe_allow_html=True) st.title("GPT-4o mini Pricing Calculator") st.markdown("Interactive cost analysis for text and audio processing using GPT-4o mini") st.markdown('
', unsafe_allow_html=True) # Sidebar navigation st.sidebar.title("Navigation") page = st.sidebar.radio("Select Page", ["Dashboard", "Text Analysis", "Audio Analysis", "Comparative Analysis", "Cost Calculator", "Documentation"]) # GPT-4o mini pricing constants TEXT_INPUT_PRICE = 0.60 # $ per 1M tokens TEXT_OUTPUT_PRICE = 2.40 # $ per 1M tokens TEXT_CACHED_PRICE = 0.30 # $ per 1M tokens AUDIO_INPUT_PRICE = 10.00 # $ per 1M tokens AUDIO_OUTPUT_PRICE = 20.00 # $ per 1M tokens AUDIO_CACHED_PRICE = 0.30 # $ per 1M tokens # Helper functions for calculations def calculate_text_costs(users, msgs_per_user, input_tokens, output_tokens, cached_pct=0): # Calculate total token counts total_input_tokens = users * msgs_per_user * input_tokens total_output_tokens = users * msgs_per_user * output_tokens # Apply caching cached_input_tokens = total_input_tokens * (cached_pct / 100) standard_input_tokens = total_input_tokens - cached_input_tokens # Calculate costs input_cost = (standard_input_tokens * TEXT_INPUT_PRICE / 1000000) + (cached_input_tokens * TEXT_CACHED_PRICE / 1000000) output_cost = total_output_tokens * TEXT_OUTPUT_PRICE / 1000000 total_cost = input_cost + output_cost return { 'input_tokens': total_input_tokens, 'output_tokens': total_output_tokens, 'input_cost': input_cost, 'output_cost': output_cost, 'total_cost': total_cost, 'cost_per_message': total_cost / (users * msgs_per_user) if users * msgs_per_user > 0 else 0 } def calculate_audio_costs(users, audio_minutes, tokens_per_sec=600, output_ratio=0.05, cached_pct=0): # Calculate token counts seconds = audio_minutes * 60 total_input_tokens = users * seconds * tokens_per_sec total_output_tokens = total_input_tokens * output_ratio # Apply caching cached_input_tokens = total_input_tokens * (cached_pct / 100) standard_input_tokens = total_input_tokens - cached_input_tokens # Calculate costs input_cost = (standard_input_tokens * AUDIO_INPUT_PRICE / 1000000) + (cached_input_tokens * AUDIO_CACHED_PRICE / 1000000) output_cost = total_output_tokens * AUDIO_OUTPUT_PRICE / 1000000 total_cost = input_cost + output_cost return { 'input_tokens': total_input_tokens, 'output_tokens': total_output_tokens, 'input_cost': input_cost, 'output_cost': output_cost, 'total_cost': total_cost, 'cost_per_minute': total_cost / audio_minutes if audio_minutes > 0 else 0 } # Dashboard page if page == "Dashboard": # Key metrics overview st.header("GPT-4o mini Pricing Overview") col1, col2, col3 = st.columns(3) with col1: st.markdown('
', unsafe_allow_html=True) st.markdown('

Text Processing

', unsafe_allow_html=True) st.metric("Input Cost", f"${TEXT_INPUT_PRICE:.2f}/1M tokens") st.metric("Output Cost", f"${TEXT_OUTPUT_PRICE:.2f}/1M tokens") st.metric("Cached Input", f"${TEXT_CACHED_PRICE:.2f}/1M tokens") st.markdown('
', unsafe_allow_html=True) with col2: st.markdown('
', unsafe_allow_html=True) st.markdown('

Audio Processing

', unsafe_allow_html=True) st.metric("Input Cost", f"${AUDIO_INPUT_PRICE:.2f}/1M tokens") st.metric("Output Cost", f"${AUDIO_OUTPUT_PRICE:.2f}/1M tokens") st.metric("Cached Input", f"${AUDIO_CACHED_PRICE:.2f}/1M tokens") st.markdown('
', unsafe_allow_html=True) with col3: st.markdown('
', unsafe_allow_html=True) st.markdown('

Average Costs

', unsafe_allow_html=True) # Calculate example costs text_example = calculate_text_costs(1, 100, 15, 20) audio_example = calculate_audio_costs(1, 10) st.metric("Avg Text Cost/Message", f"${text_example['cost_per_message']:.6f}") st.metric("Avg Audio Cost/Minute", f"${audio_example['cost_per_minute']:.4f}") st.metric("Audio/Text Cost Ratio", f"{audio_example['cost_per_minute'] / (text_example['cost_per_message'] * 60):.1f}x") st.markdown('
', unsafe_allow_html=True) # Quick comparison chart st.subheader("Cost Comparison: Text vs. Audio") comparison_data = pd.DataFrame({ 'Model Type': ['Text', 'Text', 'Audio', 'Audio'], 'Cost Component': ['Input', 'Output', 'Input', 'Output'], 'Cost per 1M Tokens': [TEXT_INPUT_PRICE, TEXT_OUTPUT_PRICE, AUDIO_INPUT_PRICE, AUDIO_OUTPUT_PRICE] }) fig = px.bar(comparison_data, x='Model Type', y='Cost per 1M Tokens', color='Cost Component', barmode='group', title="Cost Comparison per 1M Tokens", color_discrete_sequence=["#3366CC", "#FF9900"]) fig.update_layout(yaxis_title="Cost ($)") st.plotly_chart(fig, use_container_width=True) # Usage scenarios st.subheader("Common Usage Scenarios") scenarios = pd.DataFrame({ 'Scenario': ['Customer Support Chat', 'Document Analysis', 'Meeting Transcription', 'Podcast Analysis', 'Phone Call Analysis'], 'Type': ['Text', 'Text', 'Audio', 'Audio', 'Audio'], 'Avg Monthly Cost': [10.50, 25.75, 185.00, 740.00, 370.00], 'Suitable Plan': ['Basic', 'Basic', 'Premium', 'Enterprise', 'Premium'] }) st.dataframe(scenarios, use_container_width=True) # Text Model Analysis elif page == "Text Analysis": st.header("GPT-4o mini Text Model Analysis") st.info(f""" **Text Model Pricing**: - Input: ${TEXT_INPUT_PRICE:.2f} per 1M tokens - Output: ${TEXT_OUTPUT_PRICE:.2f} per 1M tokens - Cached Input: ${TEXT_CACHED_PRICE:.2f} per 1M tokens """) # Parameters section with input widgets st.subheader("Usage Parameters") col1, col2 = st.columns(2) with col1: users = st.number_input("Number of Users", min_value=100, value=5000, step=100) free_pct = st.slider("% Free Tier Users", min_value=0, max_value=100, value=80) basic_pct = st.slider("% Basic Tier Users (\$12.99)", min_value=0, max_value=100, value=15) pro_pct = st.slider("% Pro Tier Users (\$24.99)", min_value=0, max_value=100, value=5) with col2: msgs_per_user_free = st.number_input("Free Tier Messages/Month", min_value=10, value=100, step=10) msgs_per_user_basic = st.number_input("Basic Tier Messages/Month", min_value=10, value=300, step=10) msgs_per_user_pro = st.number_input("Pro Tier Messages/Month", min_value=10, value=500, step=10) input_tokens = st.slider("Input Tokens per Message", min_value=5, max_value=100, value=15) output_tokens = st.slider("Output Tokens per Message", min_value=5, max_value=100, value=20) cached_pct = st.slider("% Cached Input Tokens", min_value=0, max_value=100, value=0) # Calculate user distribution total_pct = free_pct + basic_pct + pro_pct if total_pct != 100: st.warning(f"Tier percentages sum to {total_pct}%. Please adjust to equal 100%.") free_users = int(users * free_pct / 100) basic_users = int(users * basic_pct / 100) pro_users = int(users * pro_pct / 100) # Token cost calculations free_costs = calculate_text_costs(free_users, msgs_per_user_free, input_tokens, output_tokens, cached_pct) basic_costs = calculate_text_costs(basic_users, msgs_per_user_basic, input_tokens, output_tokens, cached_pct) pro_costs = calculate_text_costs(pro_users, msgs_per_user_pro, input_tokens, output_tokens, cached_pct) # Calculate revenue free_revenue = 0 basic_revenue = basic_users * 12.99 pro_revenue = pro_users * 24.99 total_revenue = free_revenue + basic_revenue + pro_revenue total_cost = free_costs['total_cost'] + basic_costs['total_cost'] + pro_costs['total_cost'] # Display metrics st.subheader("Cost Analysis") col1, col2, col3 = st.columns(3) with col1: st.metric("Total Monthly Cost", f"${total_cost:.2f}") st.metric("Total Monthly Revenue", f"${total_revenue:.2f}") with col2: profit = total_revenue - total_cost margin = (profit / total_revenue * 100) if total_revenue > 0 else 0 st.metric("Monthly Profit", f"${profit:.2f}") st.metric("Profit Margin", f"{margin:.1f}%") with col3: avg_cost_per_user = total_cost / users if users > 0 else 0 st.metric("Avg. Cost per User", f"${avg_cost_per_user:.4f}") st.metric("Total Messages/Month", f"{free_users * msgs_per_user_free + basic_users * msgs_per_user_basic + pro_users * msgs_per_user_pro:,}") # Create visualizations st.subheader("Cost Distribution") # Cost breakdown by tier tier_costs = pd.DataFrame({ 'Tier': ['Free', 'Basic', 'Pro'], 'Cost': [free_costs['total_cost'], basic_costs['total_cost'], pro_costs['total_cost']], 'Users': [free_users, basic_users, pro_users] }) col1, col2 = st.columns(2) with col1: fig = px.pie(tier_costs, values='Cost', names='Tier', title="Cost Distribution by Tier", color_discrete_sequence=px.colors.qualitative.Plotly) st.plotly_chart(fig, use_container_width=True) with col2: # Create revenue vs cost comparison comparison_data = pd.DataFrame({ 'Tier': ['Free', 'Basic', 'Pro'], 'Revenue': [free_revenue, basic_revenue, pro_revenue], 'Cost': [free_costs['total_cost'], basic_costs['total_cost'], pro_costs['total_cost']] }) fig = px.bar(comparison_data, x='Tier', y=['Revenue', 'Cost'], barmode='group', title="Revenue vs Cost by Tier", color_discrete_sequence=["#3366CC", "#FF9900"]) st.plotly_chart(fig, use_container_width=True) # Token usage breakdown st.subheader("Token Usage Analysis") token_data = pd.DataFrame({ 'Tier': ['Free', 'Basic', 'Pro'], 'Input Tokens (M)': [free_costs['input_tokens']/1000000, basic_costs['input_tokens']/1000000, pro_costs['input_tokens']/1000000], 'Output Tokens (M)': [free_costs['output_tokens']/1000000, basic_costs['output_tokens']/1000000, pro_costs['output_tokens']/1000000] }) fig = px.bar(token_data, x='Tier', y=['Input Tokens (M)', 'Output Tokens (M)'], barmode='group', title="Monthly Token Usage by Tier (Millions)", color_discrete_sequence=["#4CAF50", "#2196F3"]) st.plotly_chart(fig, use_container_width=True) # Break-even analysis st.subheader("Break-even Analysis") # Calculate fixed costs (assumed) fixed_costs = 2000 # Calculate contribution margin per user type cm_basic = 12.99 - (basic_costs['total_cost'] / basic_users if basic_users > 0 else 0) cm_pro = 24.99 - (pro_costs['total_cost'] / pro_users if pro_users > 0 else 0) # Calculate break-even point total_cm = (cm_basic * basic_users) + (cm_pro * pro_users) break_even_users = int(fixed_costs / (total_cm / (basic_users + pro_users))) if basic_users + pro_users > 0 else 0 col1, col2 = st.columns(2) with col1: st.metric("Fixed Monthly Costs", f"${fixed_costs:.2f}") st.metric("Contribution Margin (Basic)", f"${cm_basic:.2f}/user") st.metric("Contribution Margin (Pro)", f"${cm_pro:.2f}/user") with col2: st.metric("Break-even Point", f"{break_even_users:,} paid users") be_conversion = break_even_users / (users * (basic_pct + pro_pct) / 100) if users * (basic_pct + pro_pct) / 100 > 0 else 0 st.metric("Required Conversion Rate", f"{be_conversion:.1%}") # Audio Model Analysis elif page == "Audio Analysis": st.header("GPT-4o mini Audio Model Analysis") st.info(f""" **Audio Model Pricing**: - Input: ${AUDIO_INPUT_PRICE:.2f} per 1M tokens - Output: ${AUDIO_OUTPUT_PRICE:.2f} per 1M tokens - Cached Input: ${AUDIO_CACHED_PRICE:.2f} per 1M tokens """) # Audio model parameters st.subheader("Audio Processing Parameters") col1, col2 = st.columns(2) with col1: audio_minutes = st.number_input("Average Minutes of Audio/Month/User", min_value=1, value=10, step=1) tokens_per_sec = st.number_input("Audio Tokens per Second", min_value=100, value=600, step=10) users = st.number_input("Number of Users", min_value=10, value=1000, step=10) with col2: output_tokens_ratio = st.slider("Output:Input Token Ratio", min_value=0.01, max_value=0.20, value=0.05, step=0.01) cached_ratio = st.slider("% Input Tokens Cached", min_value=0, max_value=100, value=20) pricing_tier = st.selectbox("Pricing Model", ["B2C App (\$12.99/month)", "B2B Service (\$299/month)", "Enterprise (\$2500/month)"]) # Calculate costs audio_costs = calculate_audio_costs(users, audio_minutes, tokens_per_sec, output_tokens_ratio, cached_ratio) # Pricing model revenue if pricing_tier == "B2C App (\$12.99/month)": price_per_user = 12.99 elif pricing_tier == "B2B Service (\$299/month)": price_per_user = 299 else: # Enterprise price_per_user = 2500 revenue = users * price_per_user cost_per_user = audio_costs['total_cost'] / users if users > 0 else 0 profit = revenue - audio_costs['total_cost'] margin = (profit / revenue) * 100 if revenue > 0 else 0 # Display metrics and charts st.subheader("Cost Metrics") col1, col2, col3 = st.columns(3) with col1: st.metric("Cost per Minute", f"${(audio_costs['total_cost']/audio_minutes/users):.4f}") st.metric("Total Monthly Cost", f"${audio_costs['total_cost']:.2f}") with col2: st.metric("Monthly Revenue", f"${revenue:.2f}") st.metric("Monthly Profit", f"${profit:.2f}") with col3: st.metric("Profit Margin", f"{margin:.1f}%") st.metric("Cost per User", f"${cost_per_user:.2f}") # Visualization - Cost breakdown st.subheader("Cost Breakdown") # Calculate components standard_input_cost = audio_costs['input_tokens'] * (1 - cached_ratio/100) * AUDIO_INPUT_PRICE / 1000000 cached_input_cost = audio_costs['input_tokens'] * (cached_ratio/100) * AUDIO_CACHED_PRICE / 1000000 output_cost = audio_costs['output_cost'] cost_components = pd.DataFrame({ 'Component': ['Standard Input Cost', 'Cached Input Cost', 'Output Cost'], 'Cost': [standard_input_cost, cached_input_cost, output_cost] }) col1, col2 = st.columns(2) with col1: fig = px.pie(cost_components, values='Cost', names='Component', title="Audio Processing Cost Distribution", color_discrete_sequence=px.colors.qualitative.Pastel) st.plotly_chart(fig, use_container_width=True) with col2: fig = px.bar(cost_components, x='Component', y='Cost', title="Cost Component Comparison", color_discrete_sequence=["#4CAF50", "#2196F3", "#FF9800"]) st.plotly_chart(fig, use_container_width=True) # Caching impact analysis st.subheader("Impact of Caching on Costs") cache_options = [0, 20, 40, 60, 80, 100] cache_costs = [] for cache_pct in cache_options: cache_result = calculate_audio_costs(users, audio_minutes, tokens_per_sec, output_tokens_ratio, cache_pct) cache_costs.append(cache_result['total_cost']) cache_data = pd.DataFrame({ 'Cache Percentage': cache_options, 'Total Cost': cache_costs, 'Savings': [audio_costs['total_cost'] - cost for cost in cache_costs], 'Savings Percentage': [(audio_costs['total_cost'] - cost) / audio_costs['total_cost'] * 100 if audio_costs['total_cost'] > 0 else 0 for cost in cache_costs] }) fig = px.line(cache_data, x='Cache Percentage', y='Total Cost', markers=True, title="Effect of Caching on Total Cost", labels={'Cache Percentage': 'Cached Input Tokens (%)', 'Total Cost': 'Total Cost ($)'}, color_discrete_sequence=["#FF5722"]) st.plotly_chart(fig, use_container_width=True) # Optimization recommendations if margin < 50: st.warning("Warning: Low profit margin detected. Consider optimization strategies below.") with st.expander("📈 Cost Optimization Strategies"): st.markdown(""" 1. **Increase Caching**: Boost cached input ratio to reduce costs by up to 97% 2. **Hybrid Processing**: Use specialized audio services for initial transcription 3. **Input Token Optimization**: Filter silence and implement smart chunking 4. **Tiered Processing**: Apply different processing depths based on user needs """) # Calculate hybrid model savings hybrid_cost = (audio_costs['input_tokens'] * 0.006 / 1000000) + (audio_costs['output_tokens'] * TEXT_OUTPUT_PRICE / 1000000) hybrid_savings = audio_costs['total_cost'] - hybrid_cost hybrid_savings_pct = (hybrid_savings / audio_costs['total_cost']) * 100 if audio_costs['total_cost'] > 0 else 0 st.info(f""" **Hybrid Model Potential Savings**: ${hybrid_savings:.2f} ({hybrid_savings_pct:.1f}%) By using specialized transcription services (like Whisper) at \$0.006/min and processing the resulting text with GPT-4o mini text pricing. """) # Comparative Analysis elif page == "Comparative Analysis": st.header("Text vs. Audio Comparative Analysis") # Cost comparison by use case st.subheader("Cost Analysis by Use Case") use_cases = pd.DataFrame({ 'Use Case': ['Customer Service', 'Content Creation', 'Data Analysis', 'Meeting Transcription'], 'Text Cost ($)': [0.05, 0.12, 0.08, 0.15], 'Audio Cost ($)': [1.85, 4.20, 2.10, 11.10], 'Cost Ratio': [37, 35, 26, 74], 'Recommended Model': ['Text', 'Text', 'Text', 'Hybrid'] }) st.dataframe(use_cases, use_container_width=True) # Cost scaling visualization st.subheader("Cost Scaling with User Count") # Toggle for linear/log scale scale_type = st.radio("Scale Type", ["Linear", "Logarithmic"], horizontal=True) # Generate data for comparison users_range = [100, 500, 1000, 5000, 10000, 50000, 100000] text_costs = [users * 0.0001 * 300 for users in users_range] # 300 msgs avg audio_costs = [users * 0.37 * 10 for users in users_range] # 10 minutes avg scaling_data = pd.DataFrame({ 'Users': users_range, 'Text Processing Cost': text_costs, 'Audio Processing Cost': audio_costs }) # Create the chart fig = px.line(scaling_data, x='Users', y=['Text Processing Cost', 'Audio Processing Cost'], markers=True, title="Cost Scaling by User Count", color_discrete_sequence=["#3366CC", "#FF9900"]) if scale_type == "Logarithmic": fig.update_layout(yaxis_type="log") st.plotly_chart(fig, use_container_width=True) # Break-even analysis st.subheader("Break-even Analysis") col1, col2 = st.columns(2) with col1: monthly_subscription = st.slider("Monthly Subscription ($)", min_value=5.0, max_value=50.0, value=12.99, step=0.99) text_usage = st.slider("Avg. Messages per User", min_value=50, max_value=1000, value=300, step=50) with col2: audio_mins = st.slider("Avg. Audio Minutes per User", min_value=1, max_value=60, value=10, step=1) fixed_costs = st.number_input("Monthly Fixed Costs ($)", min_value=0, value=2000, step=100) # Calculate break-even points text_cost_per_user = calculate_text_costs(1, text_usage, 15, 20)['total_cost'] audio_cost_per_user = calculate_audio_costs(1, audio_mins)['total_cost'] text_contribution = monthly_subscription - text_cost_per_user audio_contribution = monthly_subscription - audio_cost_per_user text_break_even = fixed_costs / text_contribution if text_contribution > 0 else float('inf') audio_break_even = fixed_costs / audio_contribution if audio_contribution > 0 else float('inf') # Display break-even metrics col1, col2 = st.columns(2) with col1: st.metric("Text Break-even Users", f"{int(text_break_even)}") st.metric("Text Margin per User", f"${text_contribution:.2f} ({text_contribution/monthly_subscription*100:.1f}%)") with col2: st.metric("Audio Break-even Users", f"{int(audio_break_even)}") st.metric("Audio Margin per User", f"${audio_contribution:.2f} ({audio_contribution/monthly_subscription*100:.1f}%)") # Create a combined visualization st.subheader("Profit Analysis") user_counts = list(range(0, 10001, 500)) text_profits = [(monthly_subscription - text_cost_per_user) * users - fixed_costs for users in user_counts] audio_profits = [(monthly_subscription - audio_cost_per_user) * users - fixed_costs for users in user_counts] profit_data = pd.DataFrame({ 'Users': user_counts, 'Text Profit': text_profits, 'Audio Profit': audio_profits }) fig = px.line(profit_data, x='Users', y=['Text Profit', 'Audio Profit'], title="Profit by User Count", labels={'value': 'Profit ($)', 'Users': 'Number of Users'}, color_discrete_sequence=["#3366CC", "#FF9900"]) fig.add_hline(y=0, line_dash="dash", line_color="red") st.plotly_chart(fig, use_container_width=True) # Business model recommendations st.subheader("Business Model Recommendations") if audio_cost_per_user > monthly_subscription: st.warning(f""" ⚠️ Audio processing costs (${audio_cost_per_user:.2f}/user) exceed subscription price (${monthly_subscription:.2f}). Consider increasing subscription price or implementing usage limits for audio features. """) recommended_model = "Text-Only" if text_contribution > audio_contribution else "Hybrid" st.success(f""" ✅ Recommended Business Model: **{recommended_model}** Based on your inputs, a {'text-focused approach' if recommended_model == 'Text-Only' else 'hybrid approach with limited audio processing'} would maximize profitability while maintaining competitive pricing. """) # Cost Calculator elif page == "Cost Calculator": st.header("Interactive Cost Calculator") # Choose model type model_type = st.selectbox("Select Model Type", ["Text", "Audio", "Hybrid"]) if model_type == "Text": st.subheader("GPT-4o mini Text Model Calculator") # Input parameters col1, col2 = st.columns(2) with col1: total_users = st.number_input("Total Users", min_value=1, value=1000, step=100) msgs_per_user = st.number_input("Monthly Messages per User", min_value=1, value=300, step=10) input_tokens = st.number_input("Avg. Input Tokens per Message", min_value=1, value=15, step=1) output_tokens = st.number_input("Avg. Output Tokens per Message", min_value=1, value=20, step=1) with col2: subscription_price = st.number_input("Monthly Subscription Price ($)", min_value=0.0, value=12.99, step=0.99) free_tier_ratio = st.slider("Free:Paid User Ratio", min_value=0.0, max_value=20.0, value=9.0, step=0.1) cached_pct = st.slider("% Cached Input", min_value=0, max_value=100, value=0, step=5) # Calculate values free_users = int(total_users * (free_tier_ratio / (free_tier_ratio + 1))) paid_users = total_users - free_users # Free tier calculations free_msgs_limit = 100 # Free tier message limit free_total_msgs = free_users * min(msgs_per_user, free_msgs_limit) # Token calculations free_costs = calculate_text_costs(free_users, min(msgs_per_user, free_msgs_limit), input_tokens, output_tokens, cached_pct) paid_costs = calculate_text_costs(paid_users, msgs_per_user, input_tokens, output_tokens, cached_pct) total_cost = free_costs['total_cost'] + paid_costs['total_cost'] # Calculate revenue and profit revenue = paid_users * subscription_price profit = revenue - total_cost margin = (profit / revenue) * 100 if revenue > 0 else 0 # Display results st.subheader("Results") col1, col2, col3, col4 = st.columns(4) with col1: st.metric("Total Cost", f"${total_cost:.2f}") with col2: st.metric("Revenue", f"${revenue:.2f}") with col3: st.metric("Monthly Profit", f"${profit:.2f}") with col4: st.metric("Profit Margin", f"{margin:.1f}%") # Detailed breakdown with st.expander("See Detailed Cost Breakdown"): st.markdown(f""" ### User Distribution - Total Users: {total_users:,} - Free Tier Users: {free_users:,} ({free_users/total_users*100:.1f}%) - Paid Tier Users: {paid_users:,} ({paid_users/total_users*100:.1f}%) ### Token Usage - Total Input Tokens: {free_costs['input_tokens'] + paid_costs['input_tokens']:,.0f} - Total Output Tokens: {free_costs['output_tokens'] + paid_costs['output_tokens']:,.0f} ### Token Cost Breakdown - Input Cost: ${free_costs['input_cost'] + paid_costs['input_cost']:.2f} - Output Cost: ${free_costs['output_cost'] + paid_costs['output_cost']:.2f} ### Per User Economics - Cost per Paid User: ${total_cost/paid_users:.4f} (if all costs allocated to paid users) - Revenue per Paid User: ${subscription_price:.2f} - Profit per Paid User: ${(revenue-total_cost)/paid_users:.2f} """) # Visualization st.subheader("Cost vs Revenue") fig = go.Figure() fig.add_trace(go.Bar( name='Free Tier Cost', x=['Cost'], y=[free_costs['total_cost']], marker_color='#FF9900' )) fig.add_trace(go.Bar( name='Paid Tier Cost', x=['Cost'], y=[paid_costs['total_cost']], marker_color='#FF5733' )) fig.add_trace(go.Bar( name='Revenue', x=['Revenue'], y=[revenue], marker_color='#3366CC' )) fig.update_layout(barmode='stack', title="Cost vs Revenue Breakdown") st.plotly_chart(fig, use_container_width=True) elif model_type == "Audio": st.subheader("GPT-4o mini Audio Model Calculator") # Input parameters col1, col2 = st.columns(2) with col1: users = st.number_input("Number of Users", min_value=1, value=100, step=10) audio_minutes = st.number_input("Minutes of Audio per User per Month", min_value=1, value=10, step=1) tokens_per_second = st.number_input("Audio Tokens per Second", min_value=100, value=600, step=10) cached_pct = st.slider("% Cached Input", min_value=0, max_value=100, value=20, step=5) with col2: output_ratio = st.slider("Output:Input Token Ratio", min_value=0.01, max_value=0.2, value=0.05, step=0.01) subscription = st.number_input("Monthly Subscription ($)", min_value=0.0, value=29.99, step=0.99) silence_reduction = st.slider("Silence Reduction %", min_value=0, max_value=50, value=20, step=5) # Apply silence reduction to effective minutes effective_minutes = audio_minutes * (1 - silence_reduction/100) # Calculate costs costs = calculate_audio_costs(users, effective_minutes, tokens_per_second, output_ratio, cached_pct) # Calculate revenue and profit revenue = users * subscription profit = revenue - costs['total_cost'] margin = (profit / revenue) * 100 if revenue > 0 else 0 # Display results st.subheader("Results") col1, col2 = st.columns(2) with col1: st.metric("Cost per Audio Minute", f"${costs['cost_per_minute']:.4f}") st.metric("Total Monthly Cost", f"${costs['total_cost']:.2f}") st.metric("Cost per User", f"${costs['total_cost']/users:.2f}") with col2: st.metric("Monthly Revenue", f"${revenue:.2f}") st.metric("Monthly Profit", f"${profit:.2f}") st.metric("Profit Margin", f"{margin:.1f}%")