What Is an AI Credit Actually Worth? (Cross-Tool Comparison)

TL;DR: AI credits explained plainly: they're not a currency, just an internal unit each vendor prices, refills, and expires differently. The same credit can be worth 2x more on one plan than another. Convert every advertised number to cost-per-task before comparing tools, and always check what happens to what you don't spend.

Every metered AI tool eventually shows you a number of "credits" and asks you to trust it means something. It doesn't, not on its own: a credit is whatever the vendor decided it's worth this quarter, sometimes a fixed unit of compute, sometimes a fraction of a message, sometimes a number that shifts by plan. We pulled today's pricing pages for eight tools that bill this way and did the arithmetic ourselves. Some of it held up. Some of it contradicted itself on the vendor's own site.

One note before the numbers: we also tried to include Stability AI's per-generation image pricing. Its pricing and API-reference pages are entirely client-rendered, and a direct fetch today returned an empty page shell with no pricing data in it, so we've left it out rather than reconstruct old figures.

What Is an AI Credit, Actually?

A credit is not a unit of energy, compute, or anything else with a fixed, external definition. It is whatever the vendor's billing system says it is, and that changes by product, by action, and sometimes by which plan tier you're paying for. Runway's credit buys a slice of video-generation time. Make.com's credit buys one automation step, regardless of what that step does internally. Gamma's credit buys a slide or an image, priced differently depending on the AI model it calls. None of these are convertible into each other, and often they aren't even convertible within one company's own product line at a fixed rate.

That last part is what vendors don't advertise. Lovable's own pricing page states it directly: "The value of a credit and the rate at which they are consumed for a given action depend on your subscription plan and the feature used, and credits are not necessarily equal in value across different plans" (lovable.dev/pricing, accessed September 4, 2026). That's an unusually honest admission for a pricing page, and it's why converting everything to a real number is the only way to compare tools at all.

Why Can't You Compare Credits Across Tools at Face Value?

Four things determine what a credit is actually worth, and a vendor's marketing page usually only volunteers one or two of them:

1. The unit definition. What single action consumes exactly one credit, and does that rate change by model, resolution, or complexity?
2. The dollar-per-credit rate. How many credits does your specific plan include, and what do you pay for the plan?
3. The refill cadence. Do credits arrive monthly, annually, or as a one-time grant that never comes back?
4. The expiry and rollover rule. What happens to what you don't use this cycle: reset to zero, roll forward, or accumulate up to a cap?

Once you have all four, the actual cost of one task is a simple calculation:

cost_per_task = (plan_price ÷ credits_included) × credits_consumed_per_task

We ran this formula against every vendor below, using only numbers published on its own pricing or help pages, fetched today, and we label any math that's ours rather than the vendor's.

How Much Does a Second of AI Video Actually Cost?

Video-generation tools are where credit math gets the most concrete, because the underlying resource (seconds of rendered footage) maps directly to a real number.

Runway. Runway's own FAQ states plainly that "Each model uses a set number of credits per generation depending on the model, duration, and resolution — for example, Gen-4.5 uses 12 credits per second of generated video" (runwayml.com/pricing, accessed September 4, 2026). What that credit is worth in dollars depends entirely on which of three doors you buy it through:

• Standard plan, $12/month billed annually ($15 month-to-month), includes 625 credits/month, which the pricing page states equals 52 seconds of Gen-4.5. That's $12 ÷ 52s = $0.23 per second.
• Max plan, $76/month billed annually ($95 month-to-month), includes 9,500 credits/month, equal to 791 seconds of Gen-4.5. That's $76 ÷ 791s = $0.096 per second.
• Developer API, purchased directly at "$0.01 per credit" (Runway Developer Platform docs, dev.runwayml.com, accessed September 4, 2026), makes Gen-4.5 a flat 12 × $0.01 = $0.12 per second, with no plan tier involved at all.

That's a 2.4x spread between the cheapest and most expensive way to buy the exact same second of the exact same model, all from Runway, all today. The Free plan gets 125 one-time credits that Runway's FAQ confirms don't expire; Standard and Pro credits reset within 24 hours of your billing date with no rollover, while Max is the only consumer tier where "up to one month of unused credits rolls over to the following month" (same FAQ).

Kling AI. Kling also prices by the second, in its own "Unit" currency, where 1 Unit = $0.14 list price (kling.ai/dev/pricing, accessed September 4, 2026). Unlike Runway's flat per-second rate, Kling's price moves with resolution: Kling 3.0 at 720p with no native audio costs 0.6 Units/second ($0.084/s), the same model at 1080p costs 0.8 Units/second ($0.112/s), and 4K costs 3.0 Units/second ($0.42/s) regardless of audio, five times the 720p rate. Kling's docs also state a failed generation "will not deduct any unit", and unused resource-package balance "does not carry over and will be cleared upon expiration" — a stricter rule than anything Runway publishes for its paid tiers.

For more on how duration limits and resolution ceilings stack up across video models generally, see our AI video duration reference.

What Does an Automation Credit Actually Buy You?

Make.com renamed its billing unit from "operations" to "credits," but the meter didn't change: "Each module action in your scenario, like adding a Google Sheet row or fetching Gmail account data, counts as one credit" (make.com/en/pricing, accessed September 4, 2026). Unlike the video tools above, a Make credit isn't spent per finished task, it's spent per step inside one. A five-step scenario that runs once costs 5 credits; the same scenario processing 1,000 incoming records in a month costs 5,000, more than half the Free plan's entire monthly allowance, from one modest workflow.

At the same 10,000-credit volume, the plans price identical usage very differently: Core is $9/month, Pro is $16/month, and Teams is $29/month (our arithmetic from the page's own slider, all fetched today) — a 3.2x spread in effective dollars-per-credit, for no more automation capacity, only faster execution and team roles. Make's help copy confirms annual credits "only expire after 12 months instead of each month", implying monthly credits reset every cycle with no carryover, though the page never states that last part outright.

Why Do Two Pages on the Same Site Disagree About Their Own Price?

Lovable unified its credit system this year: build, hosting, and in-app AI usage now draw from one balance instead of three. Plan mode, where Lovable only thinks through a problem without touching code, costs a flat 1 credit per message. Build mode, where it actually edits your app, is usage-based, and Lovable publishes an illustrative cost table for it. Except the table isn't the same in two places we checked, both today:

Lovable is otherwise specific about expiry, which makes the contradiction above more notable, not less: monthly plan credits expire two months after they're issued, annual plan credits expire one month after the annual period ends, top-up credits last twelve months from purchase, and the Free plan's daily build-credit grant (5/day, up to 30/month) expires at the end of each day with no rollover (docs.lovable.dev/introduction/credits-and-usage, accessed September 4, 2026). Four different expiry clocks, one product.

What Happens When You Don't Use Your Credits?

Expiry rules are the least standardized part of this whole category, and Gamma builds real complexity into what sounds like a simple grant. New free users get 400 signup credits that "do not refresh"; you can add to that balance only through referrals (200 credits each) or by upgrading (help.gamma.app, accessed September 4, 2026). Paid plans behave differently: Plus, Pro, and Ultra each get a monthly refill (1,000, 4,000, and 20,000 respectively, per Gamma's own upgrade guide), and unused credits roll over up to double the plan size before they're lost. Cancel a paid plan, and Gamma's help center confirms "any remaining credits above 400 will be removed," dropping you back to the free allowance.

We can confirm Gamma's credit amounts and rules from its help docs, but not the dollar price of Plus, Pro, or Ultra: gamma.app/pricing renders its prices through a client-side widget that returned only a loading placeholder to a direct fetch today, the same failure mode as Stability AI. The mechanics are verifiable; the headline price isn't, from a plain fetch.

Is a Notion Credit or a Base44 Credit a Better Deal?

These aren't comparable products, but both name an explicit dollar-per-credit rate, which most vendors above don't.

Notion AI credits are an add-on, available only on Business and Enterprise plans, funding Custom Agents, Workers, and AI usage beyond the built-in allowance. Notion's help center is explicit: "Monthly credits cost $10 per 1,000 credits" while "Annual credits cost $13 per 1,000 credits" (notion.com/help/what-are-notion-credits, accessed September 4, 2026). Notion's own comparison table states, for monthly credits: "Reset each month. Unused credits don't carry over." For annual credits: "Expire when your subscription renews. Unused credits don't carry over." What Notion doesn't publish anywhere we could find is how many credits one Custom Agent run or Worker execution actually costs. A clean per-credit price, an opaque per-task rate: the opposite problem from most vendors above.

Base44 publishes both halves. Its pricing page splits usage into "message credits" (AI conversation turns) and "integration credits" (connected-service actions), across five tiers billed annually: Free ($0, 25 message + 100 integration credits/month), Starter ($16/month, 100 + 2,000), Builder ($40/month, 250 + 10,000), Pro ($80/month, 500 + 20,000), and Elite ($160/month, 1,200 + 50,000), all confirmed on base44.com/pricing today. Dividing price by message credits, Starter, Builder, and Pro all land on exactly $0.16 per message credit ($16÷100, $40÷250, $80÷500), while Elite drops to $0.133 ($160÷1,200), a real volume discount visible only once you do the division (that math is ours, not Base44's). Unlike Lovable and Notion, Base44's pricing page doesn't state whether unused credits roll over or expire; the only related line is that you can "top up at any time" before the cycle resets, which describes running out, not carrying over.

Are Tokens Just Another Kind of Credit?

Model providers don't usually call their unit a "credit," they call it a token, but the same problem applies: it doesn't compare cleanly across vendors. The two biggest providers have chosen opposite pricing designs.

OpenAI bands its price by context length within a single model. Its current pricing table splits every model into a "Short context" column and a "Long context" column with different per-token rates in each: GPT-5.6 Sol costs $4.00 input / $20.00 output per million tokens short-context, rising to $8.00 / $30.00 long-context (platform.openai.com/docs/pricing, accessed September 4, 2026). The brand-new GPT-6 Astra, which OpenAI began rolling out the same day we checked, follows the identical pattern: $10.00/$50.00 short context versus $20.00/$75.00 long context. The exact token count where the band switches isn't stated on this table; that threshold lives elsewhere in OpenAI's docs.

Anthropic does the opposite, for its 1M-context models, and says so directly: "A 900k-token request is billed at the same per-token rate as a 9k-token request." (platform.claude.com/docs/en/about-claude/pricing, accessed September 4, 2026). Claude Sonnet 5 is a flat $1 input / $5 output per million tokens, whether the request is nine thousand tokens or nine hundred thousand. Two companies, two deliberately opposite pricing shapes, for what looks like the same unit from the outside.

One more trap worth repeating: a token isn't a fixed amount of text across vendors, or even across one vendor's own model versions, since tokenizer efficiency differs by design. A raw price-per-token comparison can mislead the same way a raw price-per-credit comparison does. The fix is the one this whole post is built on: convert to cost per task, not the vendor's internal unit.

How We Price Prompt Architects, and Why It's Simpler

We don't use the word "credit" anywhere on our pricing or FAQ pages (prompt-architects.com/pricing and /faq, both checked again today), and that's a deliberate choice, not an oversight. We meter one thing: a prompt enhancement. The Free plan gives 5 enhancements a day, forever, with no credit card required. Pro is $4.99/month for 200 enhancements a month (currently discounted from a $10 list price as part of a launch promotion, so check the live page for the current number). Advanced is $9.99/month (discounted from $25) for unlimited enhancements. Team is $10/month plus $3.50 per additional member, for 2 to 20 people sharing one unlimited pool.

One enhancement always costs one unit, whether you're enhancing a one-line prompt or a long one, whether you pick a plain-text or JSON output, whether you choose a specific tone or leave it default. There's no per-resolution surcharge the way there is with Kling, no per-module-step meter the way there is with Make.com, and no illustrative example that contradicts itself between two of our own pages the way Lovable's currently does.

The honest reason this is simple: enhancing a prompt is a cheaper, more uniform unit of work than rendering a second of 4K video or running a multi-step coding agent for ten hours. We didn't solve a harder pricing problem than Runway or Lovable did; we picked a product where the problem barely exists in the first place. That's a genuine tradeoff, not a hidden catch, and it's worth saying plainly rather than implying our simplicity proves something it doesn't.

Credits vs Unlimited: Which Should You Actually Buy?

None of this means credits are a bad model, or that unlimited is automatically the better deal. A pay-per-second video renderer has to meter something, because a 4K clip really does cost more compute than a 480p one, and Runway's and Kling's per-second pricing is at least honest about that relationship. What you're buying with a credit system is flexibility to pay only for what you use, at the cost of needing to do the math above before every purchase decision.

"Unlimited" trades that flexibility for predictability, but rarely removes every ceiling. It usually means unlimited on the one metric the vendor chose to advertise, while some other constraint (a fair-use clause, a rate limit, a cap on a specific feature) still exists somewhere in the terms. Our own Advanced and Team plans are unlimited on enhancement count specifically; they don't hide a second undisclosed meter behind that word, but you should verify that claim on any tool that makes it, including us, rather than take it on faith. For a broader look at how "unlimited" gets used and occasionally misused across prompt tools specifically, see our breakdown of unlimited-prompt claims, and our comparison of what free tiers actually cap versus what paying unlocks.

If a tool's core cost driver scales with something real, like render time or GPU seconds, expect and accept a credit system, then run the formula above before you buy. If the cost driver is closer to a fixed action, like enhancing text or running a script, a flat unit or a genuine unlimited tier is a fairer deal, and a vendor still selling metered credits for that kind of task deserves the same scrutiny we applied to the pricing pages above. And whichever shape a vendor picks, credits or tokens or a flat count, none of it lives inside the "prompts" primitive that MCP defines for connecting AI clients to tools; that's a different, unrelated use of the word "prompt," which we cover separately in our explainer on MCP's tools, resources, and prompts.