Credits

How calls are priced, what the free allowance covers and how jobs are charged

Every billable API and MCP call is paid in credits. One credit is $0.001 at list, so 1,000 credits cost $1. All amounts are whole credits. The app itself stays free; credits pay for API and MCP use only.

Where credits come from

Free allowance

Personal workspaces get 10,000 credits at the start of each UTC month. The allowance resets to the full amount on the 1st and unused credits do not roll over. Team workspaces get no allowance.

Purchased credits

Workspace owners buy credits on the console's Billing page by card, in packs: $10 for 10,000 credits, $50 for 50,000 credits and $200 for 200,000 credits. Purchased credits never expire while the account is active. S'more can also grant credits to a workspace; they count as purchased.

Calls spend the free allowance first, then purchased credits. Repository scans are the exception: they use purchased or granted credits only, never the free allowance.

GET /api/v1/credits shows the balance. Any key can call it, and it is free.

curl -s https://app.makesmores.com/api/v1/credits \
  -H "Authorization: Bearer $SMORE_API_KEY"

{
  "object": "credits",
  "free": 3820,
  "paid": 25820,
  "available": 29640,
  "available_for_scans": 25820,
  "running_credits": 0,
  "personal": true,
  "allowance": 10000,
  "resets_at": "2026-11-01T00:00:00Z",
  "credits_enforced": true,
  "topup_url": "https://app.makesmores.com/app/console/billing",
  "key": {
    "id": "8f3c2a71-5d0e-4b9a-a6f2-0c1d9e7b4a55",
    "month_credits": 1250,
    "monthly_credit_cap": 10000,
    "cap_remaining": 8750
  }
}

Field	Meaning
`free`, `paid`	The free allowance left this month, and purchased or granted credits
`available`	What you can spend now: `free` plus `paid`
`available_for_scans`	What a scan can use: `paid` only
`running_credits`	What jobs still running have deducted. It is already out of `available`
`personal`, `allowance`	Whether this is a personal workspace, and its monthly allowance (0 for a team workspace)
`resets_at`	When the free allowance next resets, at 00:00 UTC on the 1st
`credits_enforced`	Whether S'more is charging credits yet. See Before charging starts
`topup_url`	Where an owner buys credits
`key`	The calling key's `id`, its spend this month (`month_credits`), its `monthly_credit_cap` and `cap_remaining`. The last two are null when the key has no cap

The MCP tool smore_get_credits returns the same.

How a call is priced

Each model has a rate. All models and prices lists them, and GET /api/v1/models returns them.

Writers bill per token: uncached input, cached input and output, each priced per 1M tokens. Output counts every candidate the model writes, including the ones S'more does not return. A Reddit draft writes 16 candidates per model and returns the best.
Scorers bill per item, such as a title or a post.
Every other billable call costs 1 credit: pain points, solution requests, signals, leads, content briefs, top posts, mentions, watching, profile, outreach and other actions. A profile proposal reads up to 40 pages and costs $0.15 per call.

S'more adds the parts, rounds up once and never charges less than the model's minimum, which is 1 credit:

input  = reported input tokens - cached tokens
tokens = ceil((input x input rate + cached x cached rate + output x output rate) / 1,000,000)
charge = tokens + items x item rate + request fee
charge = max(charge, minimum)   when the call succeeded
charge = 0                      when it failed, came back empty, was refused, or the model is paused

Worked examples at today's rates

Call	Tokens or items	Credits
Default Reddit draft, 3 models x 16 candidates	1,050 in, 8,880 out	1,338 credits ($1.34 at list)
Reddit draft pinned to one model	350 in, 2,960 out	446 credits ($0.446 at list)
`prose-1` email, 8 candidates	500 in, 800 out	123 credits ($0.123 at list)
Reddit Viral Score, 3 titles	3 titles	30 credits ($0.03 at list)
X Viral Score	1 post	50 credits ($0.05 at list)
Repository scan, 100-file repo	1.43M uncached, 2.41M cached, 0.23M out	about 8,463 credits (about $8.46 at list)
Repository scan, 1,000-file repo	12.2M uncached, 20.4M cached, 1.0M out	about 57,720 credits (about $57.72 at list)

Jobs take their maximum, then refund

A call pays the most it can cost before it runs, and gets back what it did not use when it finishes. Parallel calls can never spend the same credits, and there is no separate held balance to track.

S'more checks your balance and the key's cap against the most the call can cost and deducts that. If you are short, the call answers 402 credits_required and nothing runs.
The call runs.
S'more works out the real charge at the rate in force when the call started and refunds the difference.
If the call fails, is cancelled before work starts, comes back empty or ends with a failure code, S'more refunds it in full instead.

Most quick calls already cost their maximum, so nothing is refunded. Drafts and scans are where this shows:

A draft deducts, per model, every candidate at its token limit plus the prompt. A default Reddit draft at 120 words deducts about 3,318 credits ($3.32) and refunds most of it when it settles at about 1,338 credits ($1.34 at list). If one model fails, its share is refunded in full and the others settle.
A scan deducts the max_credits you send, stops when it reaches it and refunds what it did not use.

A price change while a job runs never reprices it. The console's credit history puts each day's API charges, drafts included, on one line and gives each scan its own line with its deduction and refund.

Charges on responses

Charged REST responses carry two headers:

Header	Meaning
`X-Credits-Charged`	Credits this call charged. For a job submit, this is the deduction
`X-Credits-Balance`	Available credits after the call

A draft submit also returns credits_deducted in its body, and a scan start returns it too, so MCP clients see the deduction.

Before charging starts

S'more opens the console before it starts charging credits. Until then, credits_enforced in GET /api/v1/credits is false: every call runs and is recorded with its tokens and items, so it shows in the console's Usage page, but nothing is deducted and no call answers 402 credits_required. Responses carry no X-Credits-* headers, and credits_deducted and a scan's credits_used stay 0. The prices, caps and formula on this page apply once credits_enforced turns true.

What is free

These never charge and never answer 402:

Reading a draft (GET /api/v1/drafts/{id}, smore_get_draft) and recording a choice (POST /api/v1/drafts/{id}/choice, smore_choose_draft)
Listing and reading scans, downloading a report and cancelling a scan (GET /api/v1/scans, GET /api/v1/scans/{id}, GET /api/v1/scans/{id}/report, POST /api/v1/scans/{id}/cancel, smore_get_repo_scan). A cancelled scan still pays for the tokens it used
Reading a profile proposal (GET /api/v1/profile/proposal/{id})
GET /api/v1/models, GET /api/v1/credits and smore_get_credits
Creating, listing and revoking keys

Lead agents and company research (/api/v1/agents, /api/v1/runs, /api/v1/research and their MCP tools) keep their run billing from your plan and never use credits.

Per-key caps

Any key can carry a monthly credit cap. A call that would take the key over its cap answers 402 credits_required with reason: "key_cap". API keys and scopes covers who can set and change caps.

Running out

When available credits cannot cover a call, it answers 402 with code: "credits_required". Errors shows the body. Check the code before you top up: other 402 codes mean plan limits that credits do not lift.

A refund or lost dispute on a top-up after its credits were spent can leave a negative balance. Every billable call then answers 402 until the workspace tops up.

Where credits come from​

Free allowance​

Purchased credits​

How a call is priced​

Worked examples at today's rates​

Jobs take their maximum, then refund​

Charges on responses​

Before charging starts​

What is free​

Per-key caps​

Running out​