All posts

500K free tokens a month: counting installs without signup

Nov 13, 2026 4 min read Oleg Savelev
freemium licensing privacy architecture

TokenSafe's free tier hands every developer 500,000 measured tokens of savings a month: no signup, no email, no credit card required. The trade-off has always been invisibility: an anonymous free install is a user we can count only as an anonymous counter, cannot protect from quota-wipe tricks, and can never notify about security updates. TokenSafe 2.8.0 ships the solution: zero-config community licenses. Every free machine now receives a cryptographically signed license with zero manual configuration.

What ships in 2.8.0

On the first session start, the client quietly asks our API for a free license bound to an anonymized machine fingerprint:

POST /api/community/license
{
  "machine_fp": "9f3c7a1e44b2d08ca6e5f1d3b2a9c8e7",
  "platform": "Darwin",
  "arch": "arm64",
  "agent": "claude-code",
  "version": "2.8.0"
}

→ 200 OK
{
  "success": true,
  "license_key": "TS2.eyJ0aWVyIjoiZnJlZSIsImVtYWlsIjoiY29tbXVuaXR5QHRva2Vuc2FmZS5kZXYi…",
  "reissued": false
}

No wizard, no account, and no API key. The request runs on a background thread, never blocks an active coding session, and is fully fail-open: if the server is unreachable, the client continues working on its embedded free-tier defaults and retries after a 24-hour cooldown.

The quota now lives in a signature

The monthly limit is no longer just a constant in the client: it sits inside the Ed25519-signed license payload:

$ python3 - <<'PY'
import base64, json
payload_b64 = license_key.split(".")[1]
payload = json.loads(base64.urlsafe_b64decode(payload_b64 + "=" * (-len(payload_b64) % 4)))
print(json.dumps(payload, indent=2))
PY
{
  "tier": "free",
  "email": "community@tokensafe.dev",
  "issued_at": 1762992000,
  "expires_at": 1765584000,
  "trial": false,
  "v": 2,
  "jti": "b3f1c2d4",
  "max_tokens_monthly": 500000
}

The client's quota check prefers this signed value and falls back to embedded defaults when no license is present. The consequence: we can change the community limit server-side (one environment variable, TOKENSAFE_COMMUNITY_QUOTA_MONTHLY) and every license re-issue carries the new number, reaching all active installs within the 30-day license lifetime. No client release required. Forged quotas are impossible without our private key; that is the same Ed25519 licensing that gates paid tiers.

One-way identity, one global switch

What we store per free machine, and what we never store:

Data Stored? Note
Machine fingerprint Yes One-way SHA-256 → 32 hex chars, irreversible
OS name, CPU arch Yes Coarse ("Darwin", "arm64"), without raw IDs
Agent name, version Yes "claude-code", "2.8.0"
File contents Never Nothing is ever uploaded
Prompts, code Never Nothing is ever uploaded

The fingerprint hashes platform:hostname:MAC:home into 32 hex characters: we can tell two machines apart, but we cannot reconstruct a machine identity from the hash. And there is no new settings flag: the same TOKENSAFE_TELEMETRY_DISABLED=1 switch that was already documented disables both telemetry sync and license issuance. One switch, one privacy decision, disclosed on our privacy page.

Why we don't chase bypassers

Honest engineering: the local limit is a courtesy fence, not a wall. A determined user can patch a local client; that is true of every local-first tool, and pretending otherwise would be marketing fiction. What matters is that bypassing is pointless, because everything billable is gated on the server, fail-closed:

Bypass attempt What actually happens
Wipe the local metrics counter Server-verified quota floor restores it within the telemetry heartbeat
Patch the client to skip the license Works locally, but you lose managed cloud distillation, updates, and analytics, and divergent counters still show up if telemetry stays on
Farm licenses by recreating identity Per-machine issued_count grows, issuance capped at 10 req/min per IP, and a one-line revoke bans a specific machine

The fence keeps honest users comfortable and makes abuse more expensive than the free tier is worth, without turning the product into spyware.

What we get out of it

The admin overview now answers "how big is the free base, really" with measured numbers: total machines, active in the last 30 days, and the breakdown by OS and agent. That feeds the weekly ROI digest and, more importantly, the upgrade funnel: the same fingerprint that received a free license is the one that later activates a team trial or paid seat, so conversion stops being a guess.

Try it

npx tokensafe@latest init

The free tier still needs no account: the license simply appears on your first session. If you hit the 500K ceiling, team plans start with a 7-day free trial ($29/seat/mo, or ~$24/seat/mo billed annually) with shared L3 caching, while individual plans start from $9/mo. Everything local remains free forever. For the cost mechanics behind these numbers, read measuring, not guessing.