Imported from jeremylongshore/tons-of-skills-marketplace (plugins/saas-packs/klingai-pack/skills/klingai-pricing-basics/SKILL.md). Install upstream with npx skills add jeremylongshore/tons-of-skills-marketplace --skill klingai-pricing-basics. Copyright stays with the author (MIT).

Kling AI Pricing Basics

Overview

Kling AI uses a credit-based pricing system. Credits are consumed per video/image generation based on duration, mode, and model. API pricing uses resource packs billed separately from subscription plans.

Subscription Plans (Web UI)

Warning: Paid credits expire at end of billing period. Unused credits do not roll over.

Video Generation Costs

With Native Audio (v2.6)

Image Generation Costs (Kolors)

API Resource Packs

API access is billed separately from subscriptions via prepaid packs:

1 unit = 1 credit equivalent. API pricing works out to ~$0.07-0.14 per second of generated video.

Cost Estimation

def estimate_cost(videos: int, duration: int = 5, mode: str = "standard",
                  audio: bool = False) -> dict:
    """Estimate credits needed for a batch of videos."""
    base_credits = {
        (5, "standard"): 10,
        (5, "professional"): 35,
        (10, "standard"): 20,
        (10, "professional"): 70,
    }
    per_video = base_credits.get((duration, mode), 10)
    if audio:
        per_video *= 5  # audio multiplier

    total = videos * per_video
    return {
        "videos": videos,
        "credits_per_video": per_video,
        "total_credits": total,
        "estimated_cost_usd": total * 0.14,  # high estimate
    }

# Example: 100 five-second standard videos
print(estimate_cost(100, duration=5, mode="standard"))
# → {'videos': 100, 'credits_per_video': 10, 'total_credits': 1000, 'estimated_cost_usd': 140.0}

Cost Optimization Strategies

Budget Guard

class BudgetGuard:
    """Prevent overspending by tracking credit usage."""

    def __init__(self, daily_limit: int = 500):
        self.daily_limit = daily_limit
        self._used_today = 0

    def check(self, credits_needed: int) -> bool:
        if self._used_today + credits_needed > self.daily_limit:
            raise RuntimeError(
                f"Budget exceeded: {self._used_today + credits_needed} > {self.daily_limit}"
            )
        return True

    def record(self, credits_used: int):
        self._used_today += credits_used

Prerequisites

• A named project, billing owner, approved daily and per-run credit ceilings, and a current provider pricing source. Treat the tables above as estimates until verified against the account's active plan or resource pack.
• Define the model, duration, mode, audio setting, retry allowance, and expected failure rate. Use synthetic prompts and rights-cleared media for all estimation canaries; no real customer or personal data is needed.
• Have a sandbox destination, draft/watermarked output policy, approval threshold, and a plan to cancel queued work and remove test outputs if the estimate is exceeded.

Instructions

1. Describe the workload and calculate the worst-case credits, including audio, retries, polling overhead where applicable, and a safety reserve. Check that the run fits both the project and account ceilings.
2. Run a single low-cost synthetic canary through BudgetGuard. Confirm the selected model/mode and actual credit charge before authorizing the larger run.
3. Require owner approval for the budget, destination, and promotion from draft/watermarked output to final delivery. Track actual credits by opaque run ID and aggregate model, not by prompt or media.
4. Stop when a ceiling, policy check, rate limit, or cost anomaly fires. Cancel pending work where supported, remove quarantined outputs, and restore the approved lower-cost mode or last approved plan.
5. At closeout, reconcile estimate versus actual, expire temporary artifacts and access, and retain a redacted cost receipt only.

Output

Return a budget worksheet or receipt with opaque run ID, pricing-source timestamp, model/mode/duration/audio assumptions, expected and maximum credits, reserve, actual credits, estimated currency range, approval state, canary result, destination class, retention deadline, and rollback/removal action. Exclude billing identifiers, prompts, media, user identities, and credentials.

Error Handling

• If pricing or model parameters are stale or unknown, label the estimate provisional and stop before submission; do not infer a cheaper rate.
• If credits are depleted or the charge exceeds the ceiling, pause the run and reconcile completed tasks before retrying. A policy refusal or rights failure is not a reason to retry.
• If actual usage diverges from the estimate, quarantine outputs, cancel remaining tasks, notify the billing owner, and record the redacted variance and cleanup receipt.

Examples

For a synthetic 20-clip draft run, set duration=5, mode=standard, audio=false, credits_max=200, reserve=20%, destination=sandbox-review, and watermark=draft. Require approval=granted after the canary and actual_credits<=200; otherwise cancel pending tasks and remove the canary outputs.

Resources

• Pricing Page
• API Resource Packs