# Add to your .env or shell profile
export GENERIC_LOGGER_ENDPOINT=https://ep.slashllm.com/api/v1/ingest/litellm
export GENERIC_LOGGER_HEADERS="Authorization=Bearer sb_live_your_key_here"

import asyncio
import litellm
from litellm.integrations.generic_api.generic_api_callback import GenericAPILogger

async def main():
    # Wire Slashboard — no custom code, just LiteLLM's native logger
    logger = GenericAPILogger(
        endpoint="https://ep.slashllm.com/api/v1/ingest/litellm",
        headers={"Authorization": "Bearer sb_live_your_key_here"},
    )
    litellm.callbacks = [logger]

    # Use acompletion — required for the async GenericAPILogger
    response = await litellm.acompletion(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Summarize this ticket."}],
        metadata={
            "requester_metadata": {
                "team": "support",
                "feature": "ticket-summarizer",
                "env": "production",
            },
        },
    )

    # Flush before the event loop closes
    await asyncio.sleep(1.0)
    await logger.async_send_batch()

asyncio.run(main())

# slashboard.yaml
slashboard:
  endpoint: https://ep.slashllm.com/api/v1/ingest/litellm
  api_key: sb_live_your_key_here
  log_format: json_array

import asyncio
import yaml
from litellm.integrations.generic_api.generic_api_callback import GenericAPILogger
import litellm

def load_slashboard_logger(config_path: str = "slashboard.yaml") -> GenericAPILogger:
    with open(config_path) as f:
        cfg = yaml.safe_load(f)["slashboard"]
    return GenericAPILogger(
        endpoint=cfg["endpoint"],
        headers={"Authorization": f"Bearer {cfg['api_key']}"},
        log_format=cfg.get("log_format", "json_array"),
    )

async def main():
    logger = load_slashboard_logger()   # reads slashboard.yaml
    litellm.callbacks = [logger]

    response = await litellm.acompletion(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Summarize this ticket."}],
        metadata={
            "requester_metadata": {
                "team": "support",
                "feature": "ticket-summarizer",
            },
        },
    )

    await asyncio.sleep(1.0)
    await logger.async_send_batch()

asyncio.run(main())

litellm_settings:
  callbacks: ["slashboard"]

callback_settings:
  slashboard:
    callback_type: generic_api
    endpoint: https://ep.slashllm.com/api/v1/ingest/litellm
    headers:
      Authorization: Bearer sb_live_your_key_here
    log_format: json_array
    event_types: ["llm_api_success", "llm_api_failure"]

import requests
from datetime import datetime, timezone

def track_llm_call(model, prompt_tokens, completion_tokens, cost, team, feature):
    requests.post(
        "https://ep.slashllm.com/api/v1/ingest",
        headers={"Authorization": "Bearer sb_live_your_key_here"},
        json={
            "model": model,
            "startTime": datetime.now(timezone.utc).isoformat(),
            "prompt_tokens": prompt_tokens,
            "completion_tokens": completion_tokens,
            "response_cost": cost,
            "status": "success",
            "metadata": {"team_id": team, "feature": feature},
        },
        timeout=3,
    )

async function trackLLMCall(params: {
  model: string;
  promptTokens: number;
  completionTokens: number;
  cost: number;
  team: string;
  feature: string;
}) {
  await fetch("https://ep.slashllm.com/api/v1/ingest", {
    method: "POST",
    headers: {
      Authorization: "Bearer sb_live_your_key_here",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: params.model,
      startTime: new Date().toISOString(),
      prompt_tokens: params.promptTokens,
      completion_tokens: params.completionTokens,
      response_cost: params.cost,
      status: "success",
      metadata: { team_id: params.team, feature: params.feature },
    }),
  });
}

func TrackLLMCall(model, team, feature string, promptTokens, completionTokens int, cost float64) error {
    payload, _ := json.Marshal(map[string]any{
        "model":			model,
        "startTime":			time.Now().UTC().Format(time.RFC3339),
        "prompt_tokens":		promptTokens,
        "completion_tokens":	completionTokens,
        "response_cost":		cost,
        "status":			"success",
        "metadata":			map[string]string{"team_id": team, "feature": feature},
    })
    req, _ := http.NewRequest("POST", "https://ep.slashllm.com/api/v1/ingest", bytes.NewReader(payload))
    req.Header.Set("Authorization", "Bearer sb_live_your_key_here")
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return err }
    defer resp.Body.Close()
    return nil
}

curl -O https://raw.githubusercontent.com/slashboard-io/slashboard/main/demos/litellm-test-app/slashboard_callback.py

import litellm
from slashboard_callback import SlashboardLogger
import os

os.environ["SLASHBOARD_API_KEY"] = "sb_live_your_key_here"
os.environ["SLASHBOARD_API_URL"] = "https://ep.slashllm.com"

litellm.callbacks = [SlashboardLogger()]

response = litellm.completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
    metadata={
        "requester_metadata": {
            "team": "engineering",
            "feature": "chat",
            "env": "production",
        },
    },
)

# Good — consistent team IDs across your org
TEAMS = {"engineering", "data-science", "marketing", "support", "finance"}

# Pass in every completion call (LiteLLM SDK path)
metadata = {
    "requester_metadata": {
        "team": "engineering",		# team attribution
        "feature": "code-review",	# feature/product area
        "env": "production",		# environment
    }
}

{
  "model": "claude-opus-4-6",
  "startTime": "2026-06-01T10:00:00Z",
  "prompt_tokens": 800,
  "response_cost": 0.0420,
  "request_tags": [
    { "team": "legal" },
    { "feature": "contract-review" },
    { "env": "production" },
    { "customer_tier": "enterprise" }
  ]
}

await litellm.acompletion(
    model="gpt-4o",
    messages=[...],
    metadata={
        "requester_metadata": {
            "team": "legal",
            "feature": "contract-review",
            "env": "production",
            "customer_tier": "enterprise",  # custom tag
            "experiment": "prompt-v3",	   # A/B test breakdown
        },
    },
}

# GPT-4o pricing (June 2026)
INPUT_RATE  = 2.50 / 1_000_000   # $ per token
OUTPUT_RATE = 10.0 / 1_000_000   # $ per token

input_cost  = prompt_tokens     * INPUT_RATE
output_cost = completion_tokens * OUTPUT_RATE

payload = {
    "model": "gpt-4o",
    "input_cost": input_cost,
    "output_cost": output_cost,
    "response_cost": input_cost + output_cost,
    ...
}

{ "status": "accepted", "id": "evt_a1b2c3d4…" }

{
  "events": [
    {
      "model": "gpt-4o",
      "startTime": "2026-06-01T10:00:00Z",
      "prompt_tokens": 120,
      "response_cost": 0.0024,
      "metadata": { "team_id": "engineering" }
    },
    ...
  ]
}

{ "status": "accepted", "count": 2, "ids": ["evt_a1b2…", "evt_c3d4…"] }