Managing credit usage

What credits are

Credits are Emergent's usage currency. Every action the platform takes on your behalf - generating code, running tests, publishing to the cloud, calling external APIs - consumes a small number of credits from your account balance. This metered approach keeps costs predictable and aligns what you pay with what you actually use.

The basics:

• One combined balance: all agent runs consume Emergent Credits from a single balance, whether you use Emergent's built-in LLM infrastructure or the Universal LLM Key.
• Where to see it: your current balance shows in the top-right corner of the workspace. For the detailed usage breakdown, go to Account Settings → Credit Usage (see Monitoring usage below).

What consumes credits

Credits are deducted whenever the platform performs work:

• Code generation: each time you send a prompt and Emergent's agents write, refactor or extend your app's code, credits are consumed. The amount scales with the scope of the change and the complexity of the files touched.

• Testing & validation: automated tests - unit tests, integration checks, visual regression scans - all consume credits. The more comprehensive the test suite, the higher the cost per run.

• Cloud publishes: publishing tiers carry fixed monthly fees (Starter · Launch · Grow · Scale · Elite). Republishes, replacements, and rollbacks are free of charge. Publishing your project as a separate or new app starts a new publish and consumes credits at its own tier fee.

• Integrations & scheduled tasks: calling third-party APIs, scheduling cron jobs and running background workers through Integrations & scheduled tasks each deduct credits based on execution duration and frequency.

• LLM calls via the Universal Key: if you use the Universal LLM Key to let your app call language models at runtime, those API calls are billed through your Emergent credit balance, not your personal OpenAI or Anthropic account.

sk-emergent-

Credit types, expiry & monthly reset

Credits on Emergent operate on a monthly billing cycle. At the start of each cycle (the day your plan renews), your credit balance refills to the full amount included in your plan - you do not accumulate unused subscription credits from previous months.

For example, if your plan includes 500 credits per month and you use only 200, the remaining 300 do not roll over. Your balance refills to 500 on the renewal date.

Emergent has three kinds of credits, and expiry works differently for each:

Topping up

You can add credits anytime without waiting for your monthly reset. Top-up packs are purchased in your billing settings and added to your single combined balance instantly.

Available pack sizes include: 250 credits ($50) up to 10,000+ credits ($2,000), with custom volumes also available.

Good to know:

• You can mix credit types: the platform always spends expiring credits first to maximize your value.
• Top-up credits are non-refundable: check your current balance and renewal date before deciding whether to top up or wait for your next cycle.
• High-volume teams: contact support to discuss annual prepaid bundles with volume discounts.

Running low & hitting zero

Emergent monitors your credit balance in real time as agents work on your app. A low-balance notice appears in-app when you drop below 5 credits, giving you time to top up before hitting zero.

If your balance reaches zero mid-build, the platform pauses all active generation, builds and publishes immediately. You'll see a notification in the workspace, and the build stops wherever it left off: code already written remains saved, but the agents won't continue - and your app won't go live - until you top up. There is no overage billing.

Once you add more credits (via the billing page or automatic renewal), the build auto-resumes and the agents pick up context from where they stopped. No work is lost.

Renewal & negative balance

With an active plan, your balance is topped up automatically at the start of each billing cycle.

To avoid this scenario:

• Monitor closely near renewal: watch your credit usage if you're near the end of a billing cycle.
• Set up low-balance email alerts (if available in your plan) so you're notified before hitting zero.
• Top up before large builds: manually add credits before starting a big build if your remaining balance is tight.

Estimating cost & capping spend

The cost of a single prompt varies widely - from a handful of credits for a small UI tweak to hundreds for a full feature with tests. Large or complex builds can consume hundreds or even thousands of credits depending on the scope of your prompts, the number of files generated, and the iterations required. The platform shows an estimated cost before committing large changes, so you're never surprised.

Quick estimation tips

• Start small: build a minimal version of one feature first, note the credit cost, then extrapolate for additional features.
• Review past builds: check your billing history or workspace logs to see how many credits similar prompts consumed.
• Ask in smaller chunks: breaking a big request into multiple focused prompts often gives you better control and visibility into incremental costs.
• Test with a prototype: if you're unsure how expensive a new idea will be, scaffold a simple proof-of-concept in a separate app, validate cost and feasibility, then commit to the full build.

When to top up in advance

If you're planning a major refactor, adding a complex backend integration, or converting between web and mobile (see Web to Mobile conversion), consider topping up your account beforehand. Running out mid-build can disrupt agent context and require you to re-explain requirements.

For ongoing projects, many users find that enabling auto-renewal and a comfortable monthly credit allowance provides the smoothest experience: no interruptions, and you stay in flow. If you regularly work on large, multi-file features, consider a higher-tier plan with a more generous monthly credit allowance and lower per-credit rate.

Monitoring usage

Your current balance is always visible in the top-right corner of the workspace. For the full picture, open Account Settings → Credit Usage: it shows your consumption by category (agent runs, published versions, Universal Key calls, and more).