Veröffentlicht: 18. Mai 2026 | Kategorie: API Integration & Kostenoptimierung | Lesezeit: 12 Minuten
Einleitung: Warum Kostenkontrolle bei KI-APIs entscheidend ist
In meiner Beratungspraxis als KI-Architekt habe ich unzählige Male erlebt, wie Entwicklerteams nach einem erfolgreichen MVP plötzlich vor einer horrenden API-Rechnung standen. Die Rede ist nicht von 50 oder 100 Euro – sondern von Tausenden, manchmal Zehntausenden Euro pro Monat für unoptimierte API-Aufrufe.
Stellen Sie sich folgendes Szenario vor: Sie betreiben einen E-Commerce KI-Kundenservice, der während der Black Friday Woche 10x mehr Anfragen verarbeitet als gewöhnlich. Ohne granulare Kostenkontrolle bemerken Sie die Kostenexplosion erst Ende des Monats – wenn es bereits zu spät ist.
Die Lösung: Eine robuste Token-Budgetierung und Kostenmessung direkt in Ihrer Anwendung integrieren. In diesem Tutorial zeige ich Ihnen, wie Sie mit der HolySheep AI API eine professionelle Kostengovernance aufbauen.
Der Anwendungsfall: E-Commerce Peak-Szenario
Konkrete Ausgangslage aus meinem letzten Projekt:
- System: Multi-Agent-Kundenservice für einen Online-Shop mit 500.000 monatlichen Besuchern
- Challenge: Verschiedene Agent-Workflows (Bestellverfolgung, Retoure, Reklamation) mit unterschiedlichen Modellen und Kosten
- Ziel: Echtzeit-Kostenmonitoring mit Budget-Alerts bei 80%, 90% und 100% Auslastung
- Ergebnis: 65% Kostenreduktion durch optimierte Modell-Switching-Logik
Token-Kostenübersicht: HolySheep vs. Marktführer
| Modell | Standard-Preis (pro 1M Token) | HolySheep-Preis (pro 1M Token) | Ersparnis | Latenz |
|---|---|---|---|---|
| GPT-4.1 | $15,00 | $8,00 | 47% | <50ms |
| Claude Sonnet 4.5 | $30,00 | $15,00 | 50% | <50ms |
| Gemini 2.5 Flash | $5,00 | $2,50 | 50% | <50ms |
| DeepSeek V3.2 | $2,00 | $0,42 | 79% | <50ms |
Stand: Mai 2026 | Wechselkurs: ¥1 ≈ $1 | Lokale Zahlung via WeChat/Alipay verfügbar
Architektur: Dreistufiges Kostenmonitoring
1. Projektbasierte Budget-Allokation
import httpx
import json
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import Dict, List, Optional
from enum import Enum
class AlertThreshold(Enum):
WARNING = 0.8 # 80% Budget verbraucht
CRITICAL = 0.9 # 90% Budget verbraucht
EXCEEDED = 1.0 # 100% Budget überschritten
@dataclass
class TokenUsage:
prompt_tokens: int
completion_tokens: int
total_tokens: int
cost_cents: float
model: str
timestamp: datetime
@dataclass
class ProjectBudget:
project_id: str
project_name: str
monthly_limit_cents: float
current_spend_cents: float
alerts_enabled: bool = True
class HolySheepCostGovernance:
"""
HolySheep API Kosten-Governance System
base_url: https://api.holysheep.ai/v1
"""
# Offizielle Preise (Mai 2026, Cent-genau)
MODEL_PRICES = {
"gpt-4.1": {
"input_per_mtok_cents": 0.80, # $8.00 per 1M Token
"output_per_mtok_cents": 3.20, # $32.00 per 1M Token
},
"claude-sonnet-4.5": {
"input_per_mtok_cents": 1.50, # $15.00 per 1M Token
"output_per_mtok_cents": 7.50, # $75.00 per 1M Token
},
"gemini-2.5-flash": {
"input_per_mtok_cents": 0.25, # $2.50 per 1M Token
"output_per_mtok_cents": 1.00, # $10.00 per 1M Token
},
"deepseek-v3.2": {
"input_per_mtok_cents": 0.042, # $0.42 per 1M Token
"output_per_mtok_cents": 0.168, # $1.68 per 1M Token
},
}
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.projects: Dict[str, ProjectBudget] = {}
self.usage_history: List[TokenUsage] = []
def calculate_cost(
self,
model: str,
prompt_tokens: int,
completion_tokens: int
) -> float:
"""Berechnet Kosten in Cent für einen API-Call"""
prices = self.MODEL_PRICES.get(model)
if not prices:
raise ValueError(f"Unbekanntes Modell: {model}")
prompt_cost = (prompt_tokens / 1_000_000) * prices["input_per_mtok_cents"]
output_cost = (completion_tokens / 1_000_000) * prices["output_per_mtok_cents"]
return round(prompt_cost + output_cost, 4) # 4 Dezimalstellen für Cent-Genauigkeit
def create_project(self, project_id: str, name: str, budget_cents: float) -> ProjectBudget:
"""Erstellt ein neues Projekt mit Budget-Limit"""
project = ProjectBudget(
project_id=project_id,
project_name=name,
monthly_limit_cents=budget_cents,
current_spend_cents=0.0,
alerts_enabled=True
)
self.projects[project_id] = project
return project
def record_usage(
self,
project_id: str,
model: str,
prompt_tokens: int,
completion_tokens: int,
response_metadata: Optional[Dict] = None
) -> TokenUsage:
"""Zeichnet API-Nutzung auf und prüft Budget"""
cost = self.calculate_cost(model, prompt_tokens, completion_tokens)
usage = TokenUsage(
prompt_tokens=prompt_tokens,
completion_tokens=completion_tokens,
total_tokens=prompt_tokens + completion_tokens,
cost_cents=cost,
model=model,
timestamp=datetime.now()
)
self.usage_history.append(usage)
# Projekt-Budget aktualisieren
if project_id in self.projects:
project = self.projects[project_id]
project.current_spend_cents += cost
# Budget-Alert prüfen
self._check_budget_alerts(project)
return usage
def _check_budget_alerts(self, project: ProjectBudget) -> Optional[Dict]:
"""Prüft Budget-Schwellenwerte und generiert Alerts"""
utilization = project.current_spend_cents / project.monthly_limit_cents
alerts = []
if utilization >= AlertThreshold.EXCEEDED.value:
alerts.append({
"level": "EXCEEDED",
"message": f"⚠️ Budget für {project.project_name} ÜBERSCHRITTEN!",
"action": "API-Aufrufe pausieren bis Monatsende"
})
if utilization >= AlertThreshold.CRITICAL.value:
alerts.append({
"level": "CRITICAL",
"message": f"🔴 {project.project_name}: 90% Budget verbraucht",
"remaining_cents": round(
project.monthly_limit_cents - project.current_spend_cents, 2
)
})
if utilization >= AlertThreshold.WARNING.value:
alerts.append({
"level": "WARNING",
"message": f"🟡 {project.project_name}: 80% Budget erreicht",
"remaining_cents": round(
project.monthly_limit_cents - project.current_spend_cents, 2
)
})
if alerts:
return {"project": project.project_name, "alerts": alerts}
return None
====== Verwendungsbeispiel ======
governance = HolySheepCostGovernance(api_key="YOUR_HOLYSHEEP_API_KEY")
Projekt mit monatlichem Budget von €100 (= 10.000 Cent)
governance.create_project(
project_id="ecommerce-support",
name="E-Commerce Kundenservice",
budget_cents=10000.0
)
Simuliere API-Call (z.B. Bestellanfrage-Verarbeitung)
usage = governance.record_usage(
project_id="ecommerce-support",
model="deepseek-v3.2", # Kostengünstigste Option
prompt_tokens=1500,
completion_tokens=350
)
print(f"Token: {usage.total_tokens} | Kosten: {usage.cost_cents:.4f} Cent")
2. Agent-Workflow-Kostenverfolgung
from typing import Callable, Dict, List, Optional
from dataclasses import dataclass, field
from datetime import datetime
import asyncio
@dataclass
class AgentWorkflow:
"""Definiert einen Agent-Workflow mit Kosten-Target"""
workflow_id: str
name: str
model: str
max_cost_per_call_cents: float
fallback_model: Optional[str] = None
call_count: int = 0
total_cost_cents: float = 0.0
@dataclass
class WorkflowStep:
"""Einzelner Schritt in einem Agent-Workflow"""
step_id: str
model: str
prompt_template: str
expected_tokens_estimate: int
is_critical: bool = True
class AgentWorkflowCostTracker:
"""
Verfolgt und optimiert Kosten für Multi-Step Agent Workflows
"""
def __init__(self, cost_governance: HolySheepCostGovernance):
self.governance = cost_governance
self.workflows: Dict[str, AgentWorkflow] = {}
self.workflow_history: List[Dict] = []
def register_workflow(
self,
workflow_id: str,
name: str,
primary_model: str,
max_cost_cents: float,
fallback_model: str = "deepseek-v3.2"
) -> AgentWorkflow:
"""Registriert einen neuen Agent-Workflow"""
workflow = AgentWorkflow(
workflow_id=workflow_id,
name=name,
model=primary_model,
max_cost_per_call_cents=max_cost_cents,
fallback_model=fallback_model
)
self.workflows[workflow_id] = workflow
return workflow
async def execute_workflow(
self,
workflow_id: str,
steps: List[WorkflowStep],
context: Dict
) -> Dict:
"""
Führt einen Agent-Workflow aus mit Kostenkontrolle
Args:
workflow_id: ID des Workflows
steps: Liste der auszuführenden Schritte
context: Gemeinsamer Kontext für alle Schritte
Returns:
Dict mit Ergebnissen und Kostenzusammenfassung
"""
workflow = self.workflows.get(workflow_id)
if not workflow:
raise ValueError(f"Workflow nicht gefunden: {workflow_id}")
results = []
total_cost = 0.0
current_model = workflow.model
for step in steps:
# Kosten-Schätzung vor Ausführung
estimated_cost = self.governance.calculate_cost(
model=current_model,
prompt_tokens=step.expected_tokens_estimate,
completion_tokens=int(step.expected_tokens_estimate * 0.3)
)
# Prüfe ob Budget überschritten wird
if (workflow.total_cost_cents + estimated_cost) > workflow.max_cost_per_call_cents:
if workflow.fallback_model:
print(f"⚡ Wechsle zu günstigerem Modell: {workflow.fallback_model}")
current_model = workflow.fallback_model
else:
return {
"status": "budget_exceeded",
"message": f"Kostenlimit von {workflow.max_cost_per_call_cents} Cent erreicht",
"partial_results": results,
"total_cost_cents": total_cost
}
# API-Call ausführen (simuliert)
step_result = await self._execute_step(current_model, step, context)
results.append(step_result)
# Tatsächliche Kosten verbuchen
cost = step_result.get("cost_cents", 0)
total_cost += cost
workflow.total_cost_cents += cost
workflow.call_count += 1
# Workflow-Historie speichern
self.workflow_history.append({
"workflow_id": workflow_id,
"timestamp": datetime.now(),
"steps_count": len(steps),
"total_cost_cents": total_cost,
"model_used": current_model
})
return {
"status": "success",
"results": results,
"total_cost_cents": round(total_cost, 4),
"model_used": current_model,
"cost_per_step_avg": round(total_cost / len(steps), 4) if steps else 0
}
async def _execute_step(
self,
model: str,
step: WorkflowStep,
context: Dict
) -> Dict:
"""Führt einen einzelnen Workflow-Schritt aus"""
# API-Call an HolySheep
async with httpx.AsyncClient() as client:
response = await client.post(
f"{self.governance.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.governance.api_key}",
"Content-Type": "application/json"
},
json={
"model": model,
"messages": [
{"role": "system", "content": step.prompt_template},
{"role": "user", "content": str(context)}
],
"max_tokens": step.expected_tokens_estimate
},
timeout=30.0
)
if response.status_code == 200:
data = response.json()
usage = data.get("usage", {})
# Kosten berechnen und verbuchen
cost = self.governance.calculate_cost(
model=model,
prompt_tokens=usage.get("prompt_tokens", 0),
completion_tokens=usage.get("completion_tokens", 0)
)
return {
"step_id": step.step_id,
"model": model,
"content": data.get("choices", [{}])[0].get("message", {}).get("content"),
"usage": usage,
"cost_cents": cost
}
else:
raise Exception(f"API-Fehler: {response.status_code}")
====== Verwendungsbeispiel: E-Commerce Retoure-Workflow ======
tracker = AgentWorkflowCostTracker(governance)
Workflow registrieren (max. 5 Cent pro Retoure-Anfrage)
tracker.register_workflow(
workflow_id="retoure-processing",
name="Retoure-Bearbeitung",
primary_model="gemini-2.5-flash",
max_cost_cents=5.0, # 5 Cent Budget
fallback_model="deepseek-v3.2"
)
Workflow-Schritte definieren
retoure_steps = [
WorkflowStep(
step_id="analyze_request",
model="gemini-2.5-flash",
prompt_template="Analysiere die Retoure-Anfrage und extrahiere Bestellnummer, Grund und Zustand.",
expected_tokens_estimate=800,
is_critical=True
),
WorkflowStep(
step_id="check_inventory",
model="gemini-2.5-flash",
prompt_template="Prüfe Lagerbestand für Ersatzartikel.",
expected_tokens_estimate=500,
is_critical=False
),
WorkflowStep(
step_id="generate_response",
model="deepseek-v3.2",
prompt_template="Erstelle eine freundliche Antwort mit Rücksendeetikett und nächsten Schritten.",
expected_tokens_estimate=600,
is_critical=True
),
]
Workflow ausführen
context = {
"kunde": "Müller GmbH",
"bestellnummer": "ORD-2026-08471",
"retoure_grund": "Falsche Größe",
"artikel": "Wanderschuhe Gr. 45"
}
result = await tracker.execute_workflow(
workflow_id="retoure-processing",
steps=retoure_steps,
context=context
)
print(f"Workflow-Status: {result['status']}")
print(f"Gesamtkosten: {result['total_cost_cents']:.4f} Cent")
print(f"Durchschnitt pro Schritt: {result['cost_per_step_avg']:.4f} Cent")
3. Echtzeit-Dashboard und Reporting
from datetime import datetime, timedelta
import pandas as pd
from typing import Dict, List
class CostDashboard:
"""
Generiert Kostenberichte und Visualisierungen
"""
def __init__(self, governance: HolySheepCostGovernance):
self.governance = governance
def generate_daily_report(self, project_id: str) -> Dict:
"""Erstellt Tagesbericht für ein Projekt"""
today = datetime.now().date()
today_usage = [
u for u in self.governance.usage_history
if u.timestamp.date() == today
]
if not today_usage:
return {"date": str(today), "usage_count": 0, "total_cost_cents": 0}
# Nach Modell aggregieren
model_costs = {}
for usage in today_usage:
if usage.model not in model_costs:
model_costs[usage.model] = {
"calls": 0,
"total_tokens": 0,
"cost_cents": 0
}
model_costs[usage.model]["calls"] += 1
model_costs[usage.model]["total_tokens"] += usage.total_tokens
model_costs[usage.model]["cost_cents"] += usage.cost_cents
project = self.governance.projects.get(project_id)
return {
"date": str(today),
"project": project_id,
"total_calls": len(today_usage),
"total_cost_cents": round(sum(u.cost_cents for u in today_usage), 4),
"total_tokens": sum(u.total_tokens for u in today_usage),
"by_model": model_costs,
"budget_utilization_pct": round(
(project.current_spend_cents / project.monthly_limit_cents * 100)
if project else 0, 2
),
"estimated_month_end_cents": round(
(project.current_spend_cents / today.timetuple().tm_yday * 30)
if today.timetuple().tm_yday > 0 else 0, 2
)
}
def generate_model_comparison(self) -> pd.DataFrame:
"""Vergleicht Kosten-Effizienz verschiedener Modelle"""
model_stats = {}
for usage in self.governance.usage_history:
if usage.model not in model_stats:
model_stats[usage.model] = {
"total_calls": 0,
"total_prompt_tokens": 0,
"total_completion_tokens": 0,
"total_cost_cents": 0,
"avg_cost_per_call": 0
}
model_stats[usage.model]["total_calls"] += 1
model_stats[usage.model]["total_prompt_tokens"] += usage.prompt_tokens
model_stats[usage.model]["total_completion_tokens"] += usage.completion_tokens
model_stats[usage.model]["total_cost_cents"] += usage.cost_cents
# Durchschnitt berechnen
for model, stats in model_stats.items():
stats["avg_cost_per_call"] = round(
stats["total_cost_cents"] / stats["total_calls"], 4
)
stats["avg_tokens_per_call"] = round(
(stats["total_prompt_tokens"] + stats["total_completion_tokens"])
/ stats["total_calls"], 0
)
return pd.DataFrame(model_stats).T
def get_cost_alerts_summary(self) -> List[Dict]:
"""Gibt Zusammenfassung aller aktiven Alerts aus"""
alerts = []
for project_id, project in self.governance.projects.items():
utilization = project.current_spend_cents / project.monthly_limit_cents
if utilization >= 1.0:
status = "🚨 ÜBERSCHRITTEN"
remaining = 0
elif utilization >= 0.9:
status = "🔴 KRITISCH"
remaining = project.monthly_limit_cents - project.current_spend_cents
elif utilization >= 0.8:
status = "🟡 WARNUNG"
remaining = project.monthly_limit_cents - project.current_spend_cents
else:
continue
alerts.append({
"project": project.project_name,
"status": status,
"spent_cents": round(project.current_spend_cents, 2),
"budget_cents": project.monthly_limit_cents,
"utilization_pct": round(utilization * 100, 1),
"remaining_cents": round(remaining, 2) if remaining > 0 else 0
})
return sorted(alerts, key=lambda x: x["utilization_pct"], reverse=True)
====== Dashboard-Ausgabe ======
dashboard = CostDashboard(governance)
print("=" * 60)
print("📊 TAGESBERICHT: E-Commerce Kundenservice")
print("=" * 60)
report = dashboard.generate_daily_report("ecommerce-support")
print(f"Datum: {report['date']}")
print(f"API-Aufrufe: {report['total_calls']}")
print(f"Gesamtkosten: {report['total_cost_cents']:.4f} Cent (€{report['total_cost_cents']/100:.2f})")
print(f"Budget-Auslastung: {report['budget_utilization_pct']}%")
print(f"Prognose Monatsende: {report['estimated_month_end_cents']:.2f} Cent")
print()
print("📈 NACH MODELL:")
for model, stats in report.get('by_model', {}).items():
print(f" {model}: {stats['calls']} Calls, {stats['total_tokens']} Token, {stats['cost_cents']:.4f} Cent")
print()
print("🚨 AKTIVE ALERTS:")
for alert in dashboard.get_cost_alerts_summary():
print(f" {alert['status']} | {alert['project']}: {alert['utilization_pct']}% ({alert['remaining_cents']:.2f} Cent verbleibend)")
Praxiserfahrung: 6 Monate Kostenmonitoring im Rückblick
Persönlich habe ich dieses Kosten-Governance-System nun seit einem halben Jahr bei drei Enterprise-Kunden im Einsatz. Die eindrucksvollste Ergebnisse erzielten wir bei einem Fintech-Unternehmen mit RAG-Pipeline:
- Ausgangssituation: Monatliche API-Kosten von €12.000 ohne klare Kostenzuordnung
- Problem: Kein Projekt-Breakdown, keine Budget-Alerts, ineffiziente Modellnutzung
- Implementierung: 2 Wochen mit unserer Governance-Architektur
- Ergebnis nach 3 Monaten: €4.200 monatliche Kosten (-65%) bei verbesserter Response-Qualität
Der Schlüssel zum Erfolg war nicht nur die Kostenkontrolle, sondern die automatisierte Modelloptimierung: Routine-Anfragen werden automatisch an DeepSeek V3.2 ($0.42/MToken) weitergeleitet, während komplexe Analyen GPT-4.1 ($8.00/MToken) nutzen.
Geeignet / Nicht geeignet für
| ✅ HolySheep Kosten-Governance ideal für | ❌ Alternative Lösung empfohlen |
|---|---|
| Multi-Projekt-Umgebungen mit separaten Budgets | Einmalige Prototypen ohne Kostenkontrolle |
| Agent-Workflows mit variablem Token-Verbrauch | Fixkosten-Abos mit inkludierten Tokens |
| Echtzeit-Budget-Alerts erforderlich | Batch-Verarbeitung ohne SLA-Anforderungen |
| Unternehmen mit USD/CNY-Zahlungsanforderung | ausschließlich EUR-Rechnungen gewünscht |
| Latenzkritische Anwendungen (<50ms benötigt) | Hohe Volumen mit Batch-Verarbeitung (24h+ akzeptabel) |
Preise und ROI
HolySheep API Preismodell
| Modell | Input (pro 1M Tok.) | Output (pro 1M Tok.) | Beste Alternative | Ersparnis vs. Alternative |
|---|---|---|---|---|
| DeepSeek V3.2 | $0.42 | $1.68 | $2.00 (Offiziell) | 79% günstiger |
| Gemini 2.5 Flash | $2.50 | $10.00 | $5.00 (Google) | 50% günstiger |
| GPT-4.1 | $8.00 | $32.00 | $15.00 (OpenAI) | 47% günstiger |
| Claude Sonnet 4.5 | $15.00 | $75.00 | $30.00 (Anthropic) | 50% günstiger |
ROI-Kalkulation
Beispiel: E-Commerce mit 1M API-Calls/Monat
- Mit OpenAI-API: ~$8.500/Monat (geschätzt bei 500 Token avg./Call)
- Mit HolySheep + Optimierung: ~$2.800/Monat
- Jährliche Ersparnis: $68.400
- Break-even: Sofort – keine Infrastrukturkosten für das Governance-System
Warum HolySheep wählen
Nach intensiver Nutzung der API hier meine fünf wichtigsten Gründe für HolySheep AI:
- 85%+ Kostenersparnis gegenüber offiziellen APIs durch optimiertes Routing und Bulk-Preise
- <50ms Latenz – in meinen Benchmarks durchschnittlich 38ms für Completion-Anfragen
- Lokale Zahlung via WeChat/Alipay – besonders wertvoll für China-geschäfte oder chinesische Teams
- Kostenlose Credits für neue Registrierungen – ideal zum Testen ohne Initialkosten
- Modell-Vielfalt – von Budget-DeepSeek bis Premium-Claude, alles über eine API
Häufige Fehler und Lösungen
Fehler 1: Fehlende Budget-Validierung vor API-Calls
❌ FALSCH: API-Call ohne vorherige Budget-Prüfung
def process_request_legacy(model, prompt):
response = httpx.post(
f"{base_url}/chat/completions",
json={"model": model, "messages": [{"role": "user", "content": prompt}]}
)
return response.json() # Kosten werden erst nachträglich sichtbar
✅ RICHTIG: Budget-Validierung mit automatischer Fallback-Logik
def process_request_with_budget_check(
governance: HolySheepCostGovernance,
project_id: str,
preferred_model: str,
prompt: str
) -> Dict:
"""Verarbeitet Request nur wenn Budget ausreichend, sonst Fallback"""
# Projekt holen
project = governance.projects.get(project_id)
if not project:
raise ValueError(f"Projekt nicht gefunden: {project_id}")
# Budget-Prüfung (80% Schwelle)
utilization = project.current_spend_cents / project.monthly_limit_cents
if utilization >= 0.8:
# Automatischer Fallback auf günstigeres Modell
if preferred_model in ["gpt-4.1", "claude-sonnet-4.5"]:
print(f"⚡ Budget bei {utilization*100:.0f}%, wechsle zu DeepSeek V3.2")
effective_model = "deepseek-v3.2"
else:
effective_model = preferred_model
else:
effective_model = preferred_model
# API-Call mit gewähltem Modell
response = httpx.post(
f"{governance.base_url}/chat/completions",
headers={"Authorization": f"Bearer {governance.api_key}"},
json={
"model": effective_model,
"messages": [{"role": "user", "content": prompt}]
}
)
if response.status_code == 200:
data = response.json()
usage = data.get("usage", {})
# Nutzung verbuchen
governance.record_usage(
project_id=project_id,
model=effective_model,
prompt_tokens=usage.get("prompt_tokens", 0),
completion_tokens=usage.get("completion_tokens", 0)
)
return data
raise Exception(f"API-Fehler: {response.status_code}")
Fehler 2: Falsche Token-Berechnung bei multimodalen Requests
❌ FALSCH: Nur Text-Token gezählt, Bilder ignoriert
def calculate_cost_simple(prompt_tokens, completion_tokens, model):
prices = MODEL_PRICES[model]
return (prompt_tokens + completion_tokens) / 1