القائمة
Dynamic pricing models that charge customers based on actual usage rather than fixed subscriptions
يُحدَّد Prompt الذي يراجع المصدر أولًا بشكل افتراضي. يمكنك التبديل إلى أمر مباشر أو تنزيل نسخة محلية.
اقرأ SKILL.md وأي ملفات مرافقة يعرضها SkillsMP قبل أن تقرر التثبيت.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/majiayu000/claude-skill-registry --skill usage-based-pricingيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
استنادا إلى تصنيف SOC المهني
عرض SKILL.md
| name | Usage-Based Pricing |
| description | Dynamic pricing models that charge customers based on actual usage rather than fixed subscriptions |
Current Level: Expert (Enterprise Scale) Domain: Business Strategy / Pricing / FinOps Skill ID: 127
Usage-Based Pricing (UBP) is a pricing model where customers pay based on their actual consumption of a product or service rather than fixed subscription fees. This approach aligns costs with value, reduces customer friction, and enables fair pricing across different usage patterns.
In 2025-2026, customers increasingly demand pay-as-you-go pricing that reflects their actual usage. Traditional fixed pricing models create friction for new customers and can result in overpaying or underpaying relative to value received.
Solves the critical problem where fixed pricing creates barriers for small customers while undercharging power users, resulting in missed revenue opportunities and suboptimal customer satisfaction.
Pure Usage-Based:
Tiered Usage-Based:
Hybrid Models:
Freemium + Usage:
Usage Metrics:
Pricing Dimensions:
┌─────────────┐ ┌──────────────┐ ┌─────────────┐ ┌─────────────┐
│ Customer │────▶│ Usage │────▶│ Pricing │────▶│ Invoice │
│ Activity │ │ Metering │ │ Engine │ │ Generator│
└─────────────┘ └──────────────┘ └─────────────┘ └─────────────┘
│ │ │ │
▼ ▼ ▼ ▼
┌─────────────┐ ┌──────────────┐ ┌─────────────┐ ┌─────────────┐
│ Events │ │ Usage │ │ Price │ │ Payment │
│ Stream │ │ Aggregation│ │ Tiers │ │ Processing│
└─────────────┘ └──────────────┘ └─────────────┘ └─────────────┘
Customer Segmentation:
Competitive Positioning:
Cost-Plus vs Value-Based:
# Usage-based pricing configuration
pricing_model:
type: "tiered" # pure, tiered, hybrid, freemium
# Usage metrics
metrics:
- name: "api_calls"
unit: "count"
aggregation: "sum"
description: "Number of API calls"
- name: "storage_gb"
unit: "GB"
aggregation: "max"
description: "Storage usage in GB"
- name: "compute_hours"
unit: "hours"
aggregation: "sum"
description: "Compute usage in hours"
# Pricing tiers
tiers:
- name: "starter"
min_usage: 0
max_usage: 10000
price_per_unit: 0.001
features: ["basic_support"]
- name: "growth"
min_usage: 10001
max_usage: 100000
[, ]
[, , ]
# ❌ Bad - Fixed pricing, no usage tracking
def calculate_price(customer_id):
# All customers pay the same regardless of usage
return 100.0 # $100 per month
# ✅ Good - Usage-based pricing with tiers
def calculate_usage_price(customer_id, usage_metrics):
# Calculate price based on actual usage
api_calls = usage_metrics['api_calls']
storage_gb = usage_metrics['storage_gb']
# Tiered pricing for API calls
api_price = calculate_tiered_price(api_calls, API_PRICE_TIERS)
# Storage pricing
storage_price = storage_gb * STORAGE_PRICE_PER_GB
total_price = api_price + storage_price
return total_price
# ❌ Bad - No volume discounts
def calculate_price(quantity, unit_price):
return quantity * unit_price
# ✅ Good - Volume discounts
def calculate_price_with_discounts(quantity, unit_price, discount_tiers):
price = quantity * unit_price
# Apply volume discounts
for threshold, discount in discount_tiers:
if quantity >= threshold:
price *= (1 - discount)
return price
"""
Production-ready Usage-Based Pricing Engine
"""
from typing import Dict, List, Optional, Any, Tuple
from datetime import datetime, timedelta
import pandas as pd
import numpy as np
from dataclasses import dataclass, field
from enum import Enum
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class PricingModel(Enum):
"""Types of pricing models."""
PURE = "pure"
TIERED = "tiered"
HYBRID = "hybrid"
FREEMIUM = "freemium"
class AggregationMethod(Enum):
"""Usage aggregation methods."""
SUM = "sum"
MAX = "max"
MIN = "min"
AVG = "avg"
COUNT = "count"
@dataclass
class UsageMetric:
"""Usage metric definition."""
name: str
unit: str
aggregation: AggregationMethod
description: str
@dataclass
class PricingTier:
"""Pricing tier definition."""
name:
min_usage:
max_usage: []
price_per_unit:
features: [] = field(default_factory=)
:
threshold:
discount_percent:
:
customer_id:
timestamp: datetime
metric_name:
value:
metadata: [, ] = field(default_factory=)
:
customer_id:
billing_period_start: datetime
billing_period_end: datetime
usage_breakdown: [, ]
charges: [, ]
total_amount:
currency:
:
():
.metrics = {m.name: m m metrics}
.usage_records: [UsageRecord] = []
logger.info()
() -> :
metric_name .metrics:
ValueError()
timestamp :
timestamp = datetime.utcnow()
record = UsageRecord(
customer_id=customer_id,
timestamp=timestamp,
metric_name=metric_name,
value=value,
metadata=metadata {}
)
.usage_records.append(record)
logger.debug()
() -> :
metric_name .metrics:
ValueError()
metric = .metrics[metric_name]
records = [
r r .usage_records
r.customer_id == customer_id
r.metric_name == metric_name
start_date <= r.timestamp <= end_date
]
records:
values = [r.value r records]
metric.aggregation == AggregationMethod.SUM:
(values)
metric.aggregation == AggregationMethod.MAX:
(values)
metric.aggregation == AggregationMethod.MIN:
(values)
metric.aggregation == AggregationMethod.AVG:
(values) / (values)
metric.aggregation == AggregationMethod.COUNT:
(values)
:
ValueError()
() -> [, ]:
usage = {}
metric_name .metrics:
usage[metric_name] = .aggregate_usage(
customer_id, metric_name, start_date, end_date
)
usage
:
():
.pricing_model = pricing_model
.metrics = {m.name: m m metrics}
.tiers = (tiers, key= t: t.min_usage)
.volume_discounts = (volume_discounts [], key= d: d.threshold)
.base_price = base_price
.free_tier_units = free_tier_units
.usage_meter = UsageMeter(metrics)
logger.info()
() -> [, PricingTier]:
tier =
t .tiers:
t.min_usage <= usage (t.max_usage usage <= t.max_usage):
tier = t
tier :
tier = .tiers[-]
price = usage * tier.price_per_unit
price, tier
() -> :
discount .volume_discounts:
total_usage >= discount.threshold:
price *= ( - discount.discount_percent / )
price
() -> Invoice:
usage = .usage_meter.get_customer_usage(
customer_id, start_date, end_date
)
charges = {}
total_usage =
metric_name, value usage.items():
value > .free_tier_units:
billable_usage = value - .free_tier_units
:
billable_usage =
billable_usage > :
price, tier = .calculate_tiered_price(billable_usage, metric_name)
charges[metric_name] = {
: billable_usage,
: price,
: tier.name,
: tier.price_per_unit
}
total_usage += billable_usage
subtotal = (c[] c charges.values())
.pricing_model == PricingModel.HYBRID:
subtotal += .base_price
charges[] = {
: ,
: .base_price,
: ,
: .base_price
}
total_amount = .apply_volume_discounts(subtotal, total_usage)
invoice = Invoice(
customer_id=customer_id,
billing_period_start=start_date,
billing_period_end=end_date,
usage_breakdown=usage,
charges=charges,
total_amount=total_amount,
currency=
)
logger.info(
)
invoice
() -> :
total_price =
total_usage =
metric_name, value projected_usage.items():
value > .free_tier_units:
billable_usage = value - .free_tier_units
:
billable_usage =
billable_usage > :
price, _ = .calculate_tiered_price(billable_usage, metric_name)
total_price += price
total_usage += billable_usage
.pricing_model == PricingModel.HYBRID:
total_price += .base_price
total_price = .apply_volume_discounts(total_price, total_usage)
total_price
__name__ == :
metrics = [
UsageMetric(
name=,
unit=,
aggregation=AggregationMethod.SUM,
description=
),
UsageMetric(
name=,
unit=,
aggregation=AggregationMethod.MAX,
description=
)
]
tiers = [
PricingTier(
name=,
min_usage=,
max_usage=,
price_per_unit=,
features=[]
),
PricingTier(
name=,
min_usage=,
max_usage=,
price_per_unit=,
features=[, ]
),
PricingTier(
name=,
min_usage=,
max_usage=,
price_per_unit=,
features=[, ]
)
]
discounts = [
VolumeDiscount(threshold=, discount_percent=),
VolumeDiscount(threshold=, discount_percent=)
]
engine = PricingEngine(
pricing_model=PricingModel.TIERED,
metrics=metrics,
tiers=tiers,
volume_discounts=discounts,
free_tier_units=
)
customer_id =
billing_start = datetime(, , )
billing_end = datetime(, , )
i ():
engine.usage_meter.record_usage(
customer_id=customer_id,
metric_name=,
value=,
timestamp=billing_start + timedelta(days=i)
)
engine.usage_meter.record_usage(
customer_id=customer_id,
metric_name=,
value=,
timestamp=billing_start + timedelta(days=)
)
invoice = engine.calculate_price(customer_id, billing_start, billing_end)
()
()
()
()
metric, value invoice.usage_breakdown.items():
()
()
charge_name, charge_info invoice.charges.items():
()
()
()
()
projected = {
: ,
:
}
estimated = engine.estimate_price(projected)
()
Install dependencies:
pip install pandas numpy stripe
Define pricing model:
engine = PricingEngine(
pricing_model=PricingModel.TIERED,
metrics=metrics,
tiers=tiers
)
Record usage:
engine.usage_meter.record_usage(
customer_id="cust_001",
metric_name="api_calls",
value=1000
)
Generate invoice:
invoice = engine.calculate_price(customer_id, start_date, end_date)
print(f"Total: ${invoice.total_amount:.2f}")
Hidden Fees: Not clearly communicating all charges
Over-complex Pricing: Too many tiers and options
No Usage Visibility: Customers can't see their usage
Inflexible Pricing: Can't adjust to market changes
Revenue per Customer = Σ(Usage × Unit Price)
Gross Margin = (Revenue - COGS) / Revenue
Customer LTV = Average Monthly Profit × Customer Lifetime
Pricing Elasticity = % Change in Demand / % Change in Price