# Estimate Your Monthly API Cost

> Calculate a CurrencyCore bill from included requests, completed 1,000-request overage blocks, the hard cap, and the separate AI credit pool.

Canonical: https://currency-core.com/docs/guides/plan-costs/
Updated: 2026-11-12
Published: 2026-11-11

---
A plan price covers an included request count. Paid plans then bill overage in completed blocks of 1,000 requests. The word completed matters: 900 requests over the limit cost nothing, 1,000 over cost one block, and 1,900 over still cost one block. Free is a hard cap with no overage.

Only successful billable requests count toward the monthly quota. The per-minute limit counts every request, including errors and retries, but it does not add to the monthly bill. AI credits are a separate pool: native `/v1/ai` uses credits, and BYOK bills one API request per successful tool call instead.

## The formula

```text
overageBlocks = floor(max(0, requests - included) / 1000)
monthlyBill    = planPrice + overageBlocks * overageRatePer1000
```

If a hard cap is enabled, requests stop at the cap instead of producing overage.

| Plan | Price | Included requests | Overage per 1,000 |
|---|---:|---:|---:|
| Free | $0 | 1,000 | None (hard cap) |
| Starter | $9 | 50,000 | $0.10 |
| Growth | $29 | 500,000 | $0.05 |
| Growth Plus | $79 | 2,000,000 | $0.05 |
| Business | $199 | 10,000,000 | $0.03 |

Source: `PLAN_LIMITS` in `packages/shared`. Public pricing checked 2026-11-11.

## Calculate it in code

```ts
type Plan = {
  price: number;
  included: number;
  overagePer1000: number | null;
};

const PLANS = {
  free: { price: 0, included: 1_000, overagePer1000: null },
  starter: { price: 9, included: 50_000, overagePer1000: 0.1 },
  growth: { price: 29, included: 500_000, overagePer1000: 0.05 },
  "growth-plus": { price: 79, included: 2_000_000, overagePer1000: 0.05 },
  business: { price: 199, included: 10_000_000, overagePer1000: 0.03 },
} satisfies Record<string, Plan>;

export function monthlyBill(plan: Plan, requests: number): number | null {
  if (requests <= plan.included) return plan.price;
  if (plan.overagePer1000 == null) return null; // hard cap: requests return 429
  const blocks = Math.floor((requests - plan.included) / 1000);
  return plan.price + blocks * plan.overagePer1000;
}
```

The function returns `null` for a Free organization over its cap, because the
request is rejected rather than billed. It does not include tax, proration, AI
credit packs, or a custom Enterprise contract.

## Worked examples

**650,000 requests on Growth.** Overage is 150,000, or 150 completed blocks. `29 + 150 * 0.05 = $36.50`. Growth Plus would cost $79 and include 2,000,000, so Growth is cheaper at this volume unless you need a Growth Plus feature.

**2,500,000 requests on Growth Plus.** Overage is 500,000, or 500 blocks. `79 + 500 * 0.05 = $104`. Business is $199 and includes 10,000,000, so Growth Plus remains cheaper here.

**120,000 requests on Starter.** Overage is 70,000, or 70 blocks. `9 + 70 * 0.10 = $16`.

**50,900 requests on Starter.** Overage is 900, which is zero completed blocks. The bill stays at $9.

Use the next tier's included volume as a sanity check, not as an automatic upgrade trigger. A tier also changes rate limit, seats, analytics access, SSO, and audit retention. If you need those, compare the feature, not only the request math.

## What can make the real bill different

- A plan change mid-cycle, proration, tax, and the payment provider's invoice rules.
- A hard cap that blocks traffic before overage is billed.
- AI credit add-ons, which are separate from request overage.
- A custom or Enterprise contract, where the rates above do not apply.

The dashboard billing page is the source of truth for your organization. This page is a planning estimate, not an invoice. See [Billing](/docs/billing/) and [Rate limits](/docs/rate-limits/).

## Related

- [Pricing](/pricing/)
- [Rate limits](/docs/rate-limits/)
- [Billing](/docs/billing/)
- [AI credits](/docs/ai-credits/)
- [All developer guides](/docs/guides/)