How to Add AI Cost Tracking to Your Python App in 3 Minutes

#ai #api #python #tutorial

Adding AI cost tracking to your Python app should not take a week. Here is how to do it in 3 minutes flat — with real code you can copy-paste.

Step 1: Install Nothing

No SDK needed. We are using plain HTTP requests.

import requests

AI_SPEND_API = "https://api.lazy-mac.com/ai-spend"

That is it. Zero dependencies beyond requests.

Step 2: Track Costs After Each AI Call

Wrap your OpenAI / Anthropic / Google calls with a simple tracking function.

def track_cost(model: str, input_tokens: int, output_tokens: int, metadata: dict = None):
    """Track AI API cost via AI Spend API"""
    payload = {
        "model": model,
        "input_tokens": input_tokens,
        "output_tokens": output_tokens,
    }
    if metadata:
        payload["metadata"] = metadata

    try:
        resp = requests.post(f"{AI_SPEND_API}/track", json=payload, timeout=5)
        return resp.json()
    except requests.RequestException:
        pass  # Non-blocking — don't let tracking break your app

Step 3: Integrate With Your AI Client

Here is a complete example with OpenAI:

from openai import OpenAI

client = OpenAI()

def chat(prompt: str, model: str = "gpt-4") -> str:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )

    # Track the cost (non-blocking)
    track_cost(
        model=model,
        input_tokens=response.usage.prompt_tokens,
        output_tokens=response.usage.completion_tokens,
        metadata={"endpoint": "chat", "user": "demo"}
    )

    return response.choices[0].message.content

# Use it normally
result = chat("Explain quantum computing in 2 sentences")
print(result)

And with Anthropic:

import anthropic

claude = anthropic.Anthropic()

def ask_claude(prompt: str, model: str = "claude-3-sonnet-20240229") -> str:
    msg = claude.messages.create(
        model=model,
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    )

    track_cost(
        model=model,
        input_tokens=msg.usage.input_tokens,
        output_tokens=msg.usage.output_tokens,
        metadata={"provider": "anthropic"}
    )

    return msg.content[0].text

Bonus: Get Your Spend Report

# Daily spend summary
report = requests.get(f"{AI_SPEND_API}/report", params={
    "period": "daily",
    "group_by": "model"
}).json()

for entry in report["data"]:
    print(f"{entry['model']}: ${entry['total_cost']:.2f} ({entry['request_count']} calls)")

# Or use curl
curl "https://api.lazy-mac.com/ai-spend/report?period=daily&group_by=model"

Bonus: Set a Budget Cap

# Alert when daily spend exceeds $50
requests.post(f"{AI_SPEND_API}/budget", json={
    "daily_limit": 50.00,
    "alert_webhook": "https://hooks.slack.com/your-webhook"
})

The Full Integration (Copy-Paste Ready)

import requests
from functools import wraps

AI_SPEND_API = "https://api.lazy-mac.com/ai-spend"

def with_cost_tracking(func):
    """Decorator that automatically tracks AI costs"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        if hasattr(result, 'usage'):
            model = kwargs.get('model', getattr(result, 'model', 'unknown'))
            requests.post(f"{AI_SPEND_API}/track", json={
                "model": model,
                "input_tokens": getattr(result.usage, 'prompt_tokens',
                    getattr(result.usage, 'input_tokens', 0)),
                "output_tokens": getattr(result.usage, 'completion_tokens',
                    getattr(result.usage, 'output_tokens', 0)),
                "endpoint": func.__name__
            }, timeout=5)
        return result
    return wrapper