typed

Migrate from Claude to typed

For Pro / Max customers evaluating typed as a Claude Code fallback (or replacement, if it fits).

1. The config change

The fastest path is the typed launcher -- one curl installs it with your API key wired in:

curl -fsSL https://app.typed.cloud/install.sh | bash -s <your-typed-key>

The dashboard pre-fills the command with your key + a Copy button. Once installed, typed and t are on your PATH:

typed                  # launches `claude` against typed.cloud
t                      # one-keystroke alias, identical behavior
typed --resume <id>    # any flags pass through

The launcher sets every required env var, picks the right defaults, and skips Claude Code's first-run "approve this key?" prompt.

If you would rather wire it up by hand, typed speaks the Anthropic API directly -- set three environment variables and any Anthropic-API-compatible client switches over:

export ANTHROPIC_BASE_URL=https://api.typed.cloud
export ANTHROPIC_AUTH_TOKEN=<your typed key>   # bearer/gateway pattern
export ANTHROPIC_MODEL=typed-xhigh

ANTHROPIC_AUTH_TOKEN (which Anthropic SDKs send as Authorization: Bearer) is the recommended variable: typed.cloud is a gateway, and Claude Code understands the bearer pattern as a proxy token, so it skips the interactive "approve this key?" prompt that fires when you use ANTHROPIC_API_KEY instead. typed.cloud accepts both header shapes, so existing configs continue to work -- but new setups should prefer ANTHROPIC_AUTH_TOKEN.

The third line is required. typed uses its own model identifiers (typed-max, typed-xhigh, typed-high, typed-medium, typed-low); if your client sends an upstream model name like claude-3.5-sonnet, typed returns a 400 with the full list of valid identifiers in the error body. See section 1a below for how to choose.

The canonical list is also available programmatically -- the Anthropic SDK's client.models.list() works against typed (or curl https://api.typed.cloud/v1/models -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN"). SDK consumers that introspect the model surface see the five canonical tiers in Anthropic-API shape; back-compat aliases stay valid for /v1/messages but are intentionally omitted from discovery.

We run our own day-to-day on Claude Code against typed. Other Anthropic-API-compatible clients (Cursor, Cline, Roo Code, OpenClaw, and any tool that reads ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY from the environment) should work the same way -- the API is wire-compatible. If your client doesn't pick up the env vars, set the same values in its config file.

You can flip back at any time by swapping the variables. Nothing else changes.

1a. Choosing a model

typed exposes five effort tiers, mirroring the agent-effort vocabulary Claude Code already uses. Set ANTHROPIC_MODEL to one of these:

Model ID Use when Quality Latency Cost per request
typed-max Genuinely hard problems: architectural design, complex multi-file refactors, debugging that needs deep reasoning, anything irreversible Highest Slowest (often 10-40s on hard prompts) Highest reasoning effort applied to our text model. Most expensive per request -- reserve for hard work.
typed-xhigh (default) Production coding default. Most coding sessions. Routine refactors, feature work, code review High (cache-reliable) Fast (typically 3-8s) Same model as typed-max, dialed to "high" reasoning effort. Cache-reliable, so most coding-client traffic gets cache discounts and runs noticeably cheaper per request.
typed-high One notch below default. Use when you want serious quality but don't need the deepest reasoning High (heavier reasoning) Medium (typically 5-15s) Same model at "medium" reasoning effort. Fewer reasoning tokens generated than typed-xhigh, so a bit cheaper per request.
typed-medium Routine edits, simple refactors, quick lookups where you don't need deep reasoning Mid Fast on routine work; reasoning-heavy prompts may stretch to ~15s "Low" reasoning effort on the same text model. Significantly cheaper per request -- typical workloads land around ~10x less than typed-max.
typed-low Single-line fixes, syntax help, quick questions, trivial throwaway: echo, classify, very short edits Lowest Fastest Same model with no reasoning budget. Cheapest tier; reserve for routine and throwaway work.

The ladder is consistent: each tier carries strictly more reasoning effort than the one below it. All five tiers run the same underlying text model and differ only in how much reasoning they spend; lower tiers are cheaper because they emit fewer reasoning tokens.

1b. Running typed and Claude side by side

The launcher does not replace claude or modify your shell -- it only sets env vars on the subprocess it spawns. Both commands stay on your PATH and run as independent processes:

  • claude -- runs Claude Code against Anthropic directly with your Claude subscription auth. Unaffected by the typed install.
  • typed (or t) -- spawns Claude Code with ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN / ANTHROPIC_MODEL pointed at typed.cloud.

You can run as many of either at the same time across separate terminal panes / tmux windows / IDE terminals. Each invocation is its own process with its own environment:

Scenario Result
Pane A: claude, Pane B: typed Independent. Pane A hits Anthropic, Pane B hits typed.cloud.
N typed panes simultaneously All share one typed.cloud account / one monthly quota pool. No concurrency lock on the API side; you just burn quota proportionally.
M claude panes simultaneously All share one Anthropic subscription / one rate-limit budget. Same logic.
Mix of typed and claude panes typed.cloud's rate-limiter and Anthropic's are completely separate; the two backends don't see each other.

Toggle without rewriting aliases. Three subcommands let you flip the launcher's behavior without setting / unsetting env vars by hand:

typed status     # show current routing state + api key source
typed disable    # writes a flag file; subsequent `typed`/`t` exec `claude` WITHOUT typed env vars
                 # (your Claude subscription is used instead)
typed enable     # remove the flag file; route through typed.cloud again

Useful for bouncing between accounts mid-session without uninstalling or rewriting shell rc files.

One caveat (Claude Code's, not typed's). Claude Code writes session state to a per-project directory. Two claude-family processes (whether claude or typed/t) running in the same project directory at the same time can race on transcript / session files. Running them in different project directories -- the natural pattern when you'd want both -- is fine.

Context windows by tier. All five text tiers share the same underlying model and the same context window:

Tier Context window
typed-max / typed-xhigh / typed-high / typed-medium / typed-low ~192K tokens
Multimodal (any image-bearing request, any tier) ~262K tokens

~192K is close to Claude's 200K default. Under 200K is the typical envelope for a Claude Code session anyway. Multimodal requests cap at ~262K -- the underlying multimodal model's published ceiling.

Default is typed-xhigh. Set ANTHROPIC_MODEL=typed-xhigh for the production tier most coding sessions want -- cache-reliable, fast, with enough reasoning headroom for normal feature work. This is the right choice for ~90% of sessions.

Bump to typed-max when you have a hard problem that's worth the latency. Drop to typed-medium or typed-low when you want a quick answer on routine work and can accept slightly less depth.

Legacy aliases that work for backward compatibility:

Alias Resolves to
typed-pro typed-xhigh (the default tier)
typed-fast typed-medium
typed-long-context typed-xhigh (legacy alias from when typed had distinct long-context routing; all text tiers now share the same ~192K window)

Anything else -- including all claude-*, gpt-*, or typos -- returns a 400 with the full list of valid IDs in the error body.

2. What works identically

  • Most coding workflows: refactoring, debugging, code generation, code explanation, test writing, doc writing.
  • Image input: paste screenshots, design mockups, error messages. typed accepts the same multimodal content shape Claude does.
  • Context window: ~192K tokens on every text tier, close to Claude's 200K default. Multimodal requests (any message containing an image) cap at ~262K tokens -- the underlying multimodal model's published ceiling. typed does not currently offer a 1M-context tier (Claude has one behind the anthropic-beta: context-1m-2025-08-07 opt-in, billed at 2x input / 1.5x output above 200K). Keep the working set under 192K and any text tier handles it; the tier choice changes reasoning depth, not window size.
  • MCP servers: if your client already mounts MCP servers against Claude, the same configuration works against typed.
  • Prompt caching: available. Most reliably engages on the default typed-xhigh tier; other tiers cache on a best-effort basis.

3. What's different -- be honest

typed is a different model than Claude.

  • Different model = different responses on edge cases. Most coding work feels identical; some won't. We encourage spot-checking on the workflows that matter to you.
  • Knowledge cutoff varies by underlying model. For recent libraries, frameworks, and APIs published after the model's training, paste relevant docs into the prompt.
  • No Claude artifacts (browser-rendered code previews). Keep Claude for that surface if you rely on artifacts heavily.
  • Billing structure differs. typed bills monthly. By default, requests past quota return a 429 with a one-click top-up prompt; opt in to auto-top-up in your dashboard if you'd rather skip the prompt and auto-charge instead. Claude resets every 5 hours and weekly. Different shapes; better fit for some workflows.
  • Coding-only product surface. typed is tuned for coding workflows. General chat and creative writing will work but are not the design target.

4. The numbers

Claude Pro typed Pro Claude Max 5x typed Max
Monthly $20 $20 (same) $100 $100 (same)
Annual $200 $200 (same) not offered $1,000
Monthly usage Claude Pro standard tier ~50% more tokens than Claude Pro at the same monthly price Claude Max 5x standard tier ~50% more tokens than Claude Max 5x at the same monthly price
Image input yes yes yes yes
Context window 200K (Sonnet 4.5, Haiku 4.5); 1M beta (Sonnet 4.6, Opus 4.6/4.7) ~192K on every text tier; ~262K on multimodal 200K (Sonnet 4.5, Haiku 4.5); 1M beta (Sonnet 4.6, Opus 4.6/4.7) ~192K on every text tier; ~262K on multimodal
Prompt caching yes yes (best on typed-xhigh tier) yes yes (best on typed-xhigh tier)
Overage available yes (Extra Usage) yes (top-ups) yes (Extra Usage) yes (top-ups)
Overage rate (input) $1-5 / M tokens (Haiku to Opus, current gen) $1.67 / M (~44-67% cheaper vs Sonnet/Opus) $1-5 / M tokens (Haiku to Opus, current gen) $1.67 / M (~44-67% cheaper vs Sonnet/Opus)
Overage rate (output) $5-25 / M tokens (Haiku to Opus, current gen) $8.33 / M (~44-67% cheaper vs Sonnet/Opus) $5-25 / M tokens (Haiku to Opus, current gen) $8.33 / M (~44-67% cheaper vs Sonnet/Opus)
Billing structure 5-hour windows + weekly Monthly with auto-top-up at quota 5-hour windows + weekly Monthly with auto-top-up at quota

The pitch in one sentence: same monthly price as Claude, ~192K context across every text tier (comparable to Claude's 200K default), overage roughly half what Claude charges, monthly billing instead of rolling 5-hour windows, and an annual Max plan Anthropic does not offer.

Context window detail: typed's text tiers all share the same ~192K window, comparable to Claude's 200K default. typed does not currently offer a 1M-context option (Claude's 1M window requires the anthropic-beta: context-1m-2025-08-07 header and is billed at 2x input / 1.5x output above 200K). Multimodal requests on typed cap at ~262K (the underlying multimodal model's published ceiling). See Claude pricing and context windows for source-of-truth details on Claude's side.

Equivalence note: monthly usage equivalence is estimated against Anthropic's standard tier capacities. Anthropic does not officially publish per-tier token quotas, so the "~50% more" comparison is approximate (the 1.5x multiplier is in the middle of the 1.44x-1.67x range typed already promises on overage). typed's internal quotas (technical detail for migration evaluators -- customer-facing pricing copy uses Claude-equivalent framing per our pricing policy): Starter = 25M input + 5M output tokens per month, Pro = 67.5M input + 13.5M output, Max = 338M input + 68M output. Cache-eligible repeated-prefix workflows effectively stretch these significantly. Full methodology at typed.cloud/pricing/details.

4a. For teams

If two or more people in the same org will use typed, the Team / Team Max per-seat tiers consolidate billing under the org owner and add hosted codebase indexing.

typed Pro (solo) typed Max (solo) typed Team typed Team Max
Monthly $20 $100 $25 / seat $100 / seat
Annual $200 $1,000 not offered (V1) not offered (V1)
Who pays Individual Individual Org owner Org owner
Per-seat quota envelope n/a n/a Pro-equivalent (67.5M input + 13.5M output / mo per seat) Max-equivalent (338M input + 68M output / mo per seat)
Hosted codebase indexing no (local context only) no (local context only) yes yes
Billing period monthly or annual monthly or annual monthly only monthly only

Local context works everywhere: every Anthropic-API-compatible client reads files on your machine on every tier. Hosted codebase indexing is the additional surface Team / Team Max adds for orgs that want a shared, server-side index across seats. It is not a missing feature on solo tiers.

Codebases uploaded by a Team / Team Max org are stored and processed inside our us-west-2 AWS region only, are org-scoped (only members of the owning org can read or list them), and retain a 30-day grace post-cancellation before hard-delete. Full disclosure lives in the privacy policy ยง3.3a. Per-seat math, quota aggregation rules, and the "Why no Team annual?" rationale live on the pricing details page.

5. Sales-final policy (clearly disclosed)

All sales final. Cancellations take effect at the next renewal -- the remainder of your paid period is served normally, and your API key keeps working until the period ends.

We process discretionary refunds on a case-by-case basis for billing errors or extended service outages on our side -- email [email protected]. We do not promise an automatic refund window because cost-of-goods scales with usage, and we would rather be honest about the economics than build the refund into the price.

If you are not sure typed will work for your workflow, the right thing to do is pay for one month, try it for a week, and cancel before renewal if it does not suit you. The remaining three weeks of that month still serve normally. That is the trial.

6. Getting started

  1. Sign up at app.typed.cloud and pick a plan.
  2. The dashboard shows a one-line installer for the typed launcher (with your API key already inlined). Copy/paste, run, done.
  3. Run typed (or t) from any project directory. Usage appears in your dashboard within a few seconds of the first request.

If you would rather configure manually, set the three env vars from section 1 (ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, ANTHROPIC_MODEL) in your shell or your client's config and run your normal client.

If you hit problems, email [email protected]. Include your account email and the approximate UTC timestamp of the failed request -- that is enough for us to find the trace.

Last updated 2026-05-15.