How to Use Claude Fable 5 in Cursor

Running Claude Fable 5 in Cursor lets you hand off larger coding tasks, such as multi-file refactors, migrations, and long agent runs, without constantly steering the model. Fable 5 is Anthropic’s long-horizon coding model, designed to maintain task context across millions of tokens. Cursor can route requests to Anthropic models through your own API key, so setup mainly comes down to adding the key, enabling claude-fable-5, selecting it in the model picker, and validating that requests are actually billed through Anthropic.

Try Apidog today

If you have configured other frontier models in Cursor before, such as running DeepSeek V4 Pro inside Cursor, the flow will feel familiar. The main differences are billing and knowing when Fable 5 is worth using.

TL;DR

To use Claude Fable 5 in Cursor:

1. Open Cursor Settings.
2. Go to Models.
3. Paste your Anthropic API key.
4. Click Verify.
5. Add claude-fable-5 through the model search box.
6. Enable the model.
7. Select it from the model picker before starting a chat or agent run.

Because you are using your own Anthropic key, Anthropic bills you directly:

• $10 per million input tokens
• $50 per million output tokens

Use Fable 5 for long-horizon work such as large migrations, repository-wide refactors, and unattended agent sessions. For routine edits, switch back to a cheaper model.

Why use Fable 5 in Cursor

Most coding models perform well on small, scoped tasks:

• Write a function.
• Fix a test.
• Explain a file.
• Generate a component.

They become less reliable when a task spans many files, requires hundreds of steps, or runs for a long time. Context drifts, earlier decisions get forgotten, and the agent needs more supervision.

Claude Fable 5 is aimed at the opposite use case. Anthropic describes it as a model that can stay focused across millions of tokens and work autonomously for longer than previous Claude models. That matters in Cursor because agent mode can:

• Read files across a repository.
• Edit multiple files.
• Run commands.
• Inspect output.
• Continue iterating.

For long-running code tasks, the value is not just better code generation. It is the model’s ability to preserve the plan and keep changes consistent over time.

Anthropic’s Fable 5 announcement cites a Stripe example where the model performed a codebase-wide migration across a 50-million-line Ruby codebase in a single day. Anthropic states that this work would have taken a team more than two months by hand.

That is the category of task where Fable 5 makes sense.

Use Fable 5 when you are:

• Migrating a framework version, ORM, or serialization format across many files.
• Renaming a large API surface that must stay consistent everywhere.
• Running a Cursor agent for an extended task without step-by-step prompting.
• Refactoring legacy modules with many interdependent files.
• Asking the model to plan, execute, test, and self-correct over many iterations.

Do not use Fable 5 for every request. For a one-line fix, a quick test, or a small component, your default Cursor model will usually be faster and much cheaper. The practical skill is matching the model to the job size, similar to how you would compare Cursor against Claude Code for a given workflow.

Prerequisites

Before configuring Fable 5 in Cursor, make sure you have the following.

1. Cursor installed and updated

Custom models and bring-your-own-key settings live under Cursor Settings. Update Cursor if you have not done so recently so the model picker can recognize newer Anthropic model names.

2. A Cursor plan that supports custom models

Bring-your-own-key and custom model selection require a paid Cursor tier. The free Auto-only mode does not let you pin a specific model.

3. An Anthropic API key with Fable 5 access

Create or copy an API key from the Anthropic developer console. Confirm that your Anthropic workspace has billing enabled, because requests through this key are billed directly by Anthropic.

4. A cost estimate before you start

Fable 5 pricing is:

Input:  $10 / 1M tokens
Output: $50 / 1M tokens

Long Cursor agent runs can generate a lot of output tokens. Check the Anthropic usage dashboard while running expensive jobs.

For more context on the Claude lineup, see the Claude models overview. You can also read this Claude Fable 5 explainer.

Add Claude Fable 5 to Cursor

The setup has two parts:

1. Add your Anthropic API key to Cursor.
2. Add and enable claude-fable-5 in the model list.

Cursor’s API key documentation is the canonical reference if the UI changes, but the current flow is straightforward.

Step 1: Open Cursor Settings

Open Settings from the command palette or the gear icon.

Then go to:

Settings → Models

This panel contains:

• Available models
• Model toggles
• Provider API key fields
• Custom model options

Step 2: Find the Anthropic API key field

Scroll to the provider key section.

Find the field labeled for the Anthropic API key. This is separate from OpenAI, Google, and other provider keys.

Using this field tells Cursor to send Claude requests through your Anthropic account instead of Cursor’s bundled credits.

Step 3: Paste your Anthropic API key

Paste your key into the Anthropic API key field.

Then click:

Verify

Cursor sends a test request to confirm the key is valid.

If verification succeeds, you should see a green confirmation or checkmark.

If verification fails, check for:

• A copied key with missing characters.
• A key from the wrong Anthropic workspace.
• Anthropic billing not enabled.
• API access not available for the workspace.

Step 4: Enable the Anthropic key

After verification, make sure the Anthropic key is enabled.

Depending on your Cursor version, this may appear as:

• A toggle next to the key field.
• An “Enable Anthropic key” option.
• A provider-level enable switch.

Once enabled, Cursor can route Claude requests through your own Anthropic key.

Step 5: Add claude-fable-5

In the Models section, find the add/search model box.

Type the model ID exactly:

claude-fable-5

When it appears, choose the add action, such as:

Add Custom Model

The model should now appear in your Cursor model list.

Step 6: Enable the model

Confirm that the toggle next to claude-fable-5 is turned on.

If the model is disabled, it will not appear in the model picker during chats or agent runs.

Base URL note

If you are using the standard Anthropic API, do not change any base URL override settings.

Base URL overrides are mainly for proxies and gateways. Accidentally enabling an OpenAI base URL override can break Claude routing. Leave overrides off unless your team intentionally uses a gateway in front of Anthropic.

Select Fable 5 and verify it is active

Adding the model does not automatically mean every request uses it. Cursor lets you choose a model per chat or agent session.

Pick Fable 5 from the model picker

Open a chat or agent panel.

Click the model selector, usually near the input box or chat header.

Choose:

claude-fable-5

That selection applies to the current conversation until you change it.

Check the selector before expensive runs

Before sending a long request, confirm the picker still shows:

claude-fable-5

This is especially important if you switch between models often. Output tokens are the expensive part, so avoid accidentally running a large job on the wrong model.

Send a small test request

Before starting a real migration, send a small prompt such as:

Summarize the current file and list the main functions.

Then open your Anthropic console and check the usage dashboard.

If you see a fresh request against claude-fable-5, Cursor is routing through your Anthropic key correctly.

Watch for Anthropic fallback behavior

Anthropic routes a narrow set of requests to Claude Opus 4.8 automatically when they involve certain sensitive areas, including cybersecurity, biology and chemistry, or model distillation.

Anthropic says more than 95% of Fable sessions do not involve this fallback. For everyday coding, you will rarely notice it.

If you do hit a fallback, it is likely not a Cursor setup issue. For more context, see this Claude Opus 4.8 breakdown.

Cost and billing notes

Own-key billing is the main operational detail to understand before using Fable 5 in Cursor.

Cursor does not subsidize own-key usage

When you add your own Anthropic API key, Cursor routes requests through that key.

Anthropic bills you directly:

Input:  $10 / 1M tokens
Output: $50 / 1M tokens

This is different from Cursor’s bundled usage, where requests draw from your Cursor subscription’s included allocation.

With your own key, every token is metered on Anthropic’s side and appears on your Anthropic invoice.

Fable 5 costs twice as much as Opus 4.8

Claude Opus 4.8 pricing is:

Input:  $5 / 1M tokens
Output: $25 / 1M tokens

Fable 5 is exactly double that:

Input:  $10 / 1M tokens
Output: $50 / 1M tokens

Before using Fable 5, ask whether the task really needs long-horizon focus. If Opus 4.8 can produce the same result, it may be the better choice.

For a direct comparison, see this Fable 5 versus Opus 4.8 guide.

Output tokens are where agent runs get expensive

Cursor agent workflows can produce a lot of output because the model may:

• Write code.
• Explain changes.
• Run commands.
• Read logs.
• Generate follow-up edits.
• Summarize results.

That output can grow quickly during long autonomous runs.

Use the Anthropic dashboard while the job is running so you can stop it if usage grows beyond your budget.

Use a cheaper model by default

A practical model strategy looks like this:

Default model:
  Use for quick edits, explanations, tests, and small refactors.

Fable 5:
  Use for migrations, large refactors, repository-wide consistency tasks,
  and long unattended agent sessions.

Do not spend Fable 5 rates on a two-line change.

Cursor vs Claude Code for Fable 5

Cursor and Claude Code are both reasonable ways to use Fable 5.

Cursor is best if you want:

• A full editor.
• Inline diffs.
• File tree navigation.
• Chat next to your code.
• Easier manual review while the agent works.

Claude Code is best if you prefer:

• A terminal-native workflow.
• Shell-first automation.
• Scriptable agent sessions.
• Running tasks from the command line.

Fable 5’s long-horizon strength applies in both environments. The better choice depends on how you already work.

If you are comparing the two, read this Cursor and Claude Code comparison for 2026. There is also a guide for running Fable 5 in Claude Code.

Test the APIs Cursor builds with Apidog

When Fable 5 works on backend code, it may generate routes, handlers, request schemas, and response contracts across your project.

Do not trust generated endpoints just because the model says they work. Test them with an API client.

Apidog is an API design and testing tool that lets you send real requests, inspect responses, and verify that implementation matches the API contract.

A useful workflow is:

1. Import the API definition

If Fable 5 generated an OpenAPI or Swagger file, import it into Apidog.

Apidog reads the spec and creates the endpoints with:

• Paths
• Methods
• Parameters
• Request bodies
• Response schemas

This avoids retyping endpoint details manually.

2. Send a real request

Start your dev server.

Pick one of the generated endpoints in Apidog.

Fill in the parameters or request body and send the request.

You should inspect the actual:

• Status code
• Headers
• JSON response
• Error body, if any

3. Compare the response with the schema

Check whether the returned body matches the schema Fable 5 defined.

Look for issues such as:

• Missing fields
• Wrong field types
• Unexpected null values
• Incorrect status codes
• Inconsistent error formats

This catches gaps between generated code and the generated contract before the API reaches teammates or production.

4. Save the requests as regression checks

Group the requests into a collection.

After the next Cursor agent run, execute the same requests again.

Long-horizon agents can modify an endpoint several refactors later. Saved API requests help catch regressions immediately.

The loop is simple:

Generate in Cursor → Run locally → Test in Apidog → Fix issues → Repeat

That gives you the speed of an autonomous coding agent without skipping verification.

You now have Claude Fable 5 configured in Cursor, a way to confirm it is the model answering your requests, and the cost model needed to use it safely. Start with a task that actually needs long-horizon focus, such as a migration or wide refactor, monitor the first run, and validate generated endpoints in Apidog before shipping.

If you want to compare this setup with direct API usage, read the Claude Fable 5 API guide.