How to Use Claude Fable 5 for Web Scraping

TL;DR

• Fable 5 writes, runs, and repairs scrapers on its own, so you describe the target and get structured data back.
• A 1 million token context window and top-ranked vision let it parse bulk HTML and read values off screenshots.
• Pricing of $10 per 1M input and $50 per 1M output tokens makes Fable 5 best for the hard parts, not high-volume runs.
• Reach it through Claude.ai, the API as claude-fable-5, Claude Code with Playwright, or an MCP scraper server.

What Claude Fable 5 is

Claude Fable 5 is Anthropic's first Mythos-class model released for general use, and it arrived on June 9, 2026. The Mythos class sits above the Opus class in capability, which makes Fable 5 the strongest model you can reach through a standard Claude account.

Anthropic ships Fable 5 as the publicly safe version of the same underlying model behind Claude Mythos 5, a restricted release for a small group of cyber and infrastructure partners. Safety classifiers are the difference between the two, and the shared model means Fable 5 carries frontier capability across coding, vision, and long-running agent work.

For scraping, 3 numbers stand out. Fable 5 reads up to 1M tokens of context and writes up to 128K tokens. It carries a knowledge cutoff of January 2026, and it exposes 5 thinking effort levels from low to max that trade cost and speed for depth.

Anthropic also reports top scores on agentic, software engineering, and vision benchmarks, with the lead growing on longer and more complex tasks.

How Fable 5 compares to Opus 4.8 for scraping

Databricks ran Fable 5 against Opus 4.8 on agentic tasks and found it scored 57.9% correctness, roughly 20% more accurate while making 12% fewer tool calls. For scraping, that translates directly: the model reaches the right outcome with less back-and-forth and fewer unnecessary steps.

That efficiency comes from deeper world knowledge and longer autonomous context, which lets Fable 5 plan, write, run, and repair multi-step pipelines with less supervision, fewer wrong turns overall, not just faster individual steps.

The cost sits at roughly double the Opus line, so it earns its price on hard, reasoning-heavy work rather than simple repetitive extraction. On launch day, it felt noticeably slow, and the spend adds up quickly, but the harder challenge was finding tasks it couldn't handle.

Why Fable 5 fits web scraping

Scraping breaks into a few recurring problems: finding the right selectors, rendering JavaScript, structuring messy output, and keeping a pipeline alive as sites change. Fable 5 maps onto each one, which is what makes it useful beyond a quick demo.

Long context for bulk HTML and whole-site jobs

The 1M token window lets you load large volumes of raw HTML in a single request instead of chunking pages and stitching results back together. That capacity opens up a few patterns worth using deliberately.

• Single-pass extraction. Drop an entire category page, or several pages, into one request and pull every record at once.
• Whole-crawl parsing. Feed a crawler's output into Fable 5 and let it normalize records across hundreds of pages.
• Schema alignment. Hand it inconsistent markup from many templates and ask for one clean schema in return.

Large inputs cost real money at $10 per 1M input tokens, so size the context to the job rather than dumping everything out of habit.

Vision for screenshot-based extraction

Anthropic calls Fable 5 the new state of the art on vision tasks, and it can rebuild a web app's source code from screenshots alone. That ability turns into a practical workaround for sites that fight HTML scraping. You render the page, capture a screenshot, and ask Fable 5 to read the values straight into structured fields. Canvas-rendered charts, image-based tables, and heavily obfuscated layouts become readable without reverse engineering the markup, which often costs more time than the scrape itself.

That reliability is what makes the approach worth trusting, and independent benchmarks back it up. CharXiv, a benchmark that tests whether models can interpret and reason about complex scientific visualizations like plots, diagrams, and data charts, is a good proxy for exactly this kind of read-values-from-a-picture task.

On BenchLM.ai's CharXiv leaderboard, the closed Claude Mythos Preview leads at 93.2%, with Claude Opus 4.8 close behind at 89.9%. 22 models have been evaluated, and the spread is meaningful: the lowest-ranked entry sits at just 52.7%, well below the top tier.

The benchmark deliberately separates raw visual reasoning from tool-augmented performance, so a high score reflects the model genuinely reading the chart rather than leaning on external helpers. For a screenshot-extraction pipeline, that distinction matters because you’re betting on the model's own eyes to pull numbers off a rendered image without a clean data layer underneath.

Autonomy for end-to-end pipelines

Fable 5 runs long tasks and improves its own output using notes and memory, which suits the loop a scraper actually needs.

Point it at a target, and it can map the site, write the scraper, run it, read the failures, and patch the code, repeating until the output is clean. AI reviewers, like Simon Willison, watched it clone a repository, research an approach, and ship working code across a multi-hour session with light human input. Claire Vo, reviewing early access for Lenny's Newsletter, found it conservative on execution, which in practice means it checks its own work before declaring a job done.

Reliable code in unfamiliar tooling

Fable 5 tops frontier coding benchmarks and generalizes to tools it hasn’t seen before, which helps when a target needs an odd parser, a specific browser flag, or a niche library.

GitHub shipped it to Copilot for long-horizon coding on launch day, so it's available in GitHub Copilot and on Databricks across the major clouds. That spread means you can run the same model from a chat box, a terminal agent, or your data platform without rewriting your approach.

Use cases worth pointing to Fable 5 at

The model fits any scrape where the page structure is awkward, the number of templates is high, or the data needs cleaning on the way out. A handful of jobs come up again and again, and each one plays to a different strength.

• Extensive price and inventory monitoring. Track competitor prices, stock levels, and promotions across many retailers, with Fable 5 normalizing different page templates into one schema you can compare.
• Lead and contact lists. Pull company details, roles, and public contact fields from directories and listing sites into a clean CSV ready for a CRM.
• Research datasets. Gather structured records from public databases, catalogs, or archives for analysis, while the model reconciles inconsistent formatting across sources.
• Real estate and job listings. Scrape listings that load through JavaScript, capturing price, location, and posting date from the rendered page rather than the raw response.
• Reviews and ratings. Collect review text and scores at scale, then ask the model to tag sentiment or pull themes as it extracts, in the same pass.
• Tables inside rendered pages. Read values out of image-based or canvas-rendered tables through vision when the underlying HTML is missing or unreliable.

Across these, the pattern repeats. Fable 5 does the reasoning and the cleanup, you keep the runtime lean, and the output lands in a shape your tools can use right away.

What you need before you start

Setup stays light. A working account and a target site cover most of it, and the rest depends on how much you want to automate.

• An Anthropic account with Fable 5 access in Claude.ai, or an API key from the Claude Platform console.
• Node.js or Python installed locally for code-driven scraping, plus a terminal.
• A scraper stack of your choice, Playwright for dynamic pages, or requests, and BeautifulSoup for static HTML.
• Claude Code for agentic, self-running workflows, or Claude Cowork for a no-code path.
• A target site and a clear list of fields you want, such as title, price, and rating.

Setting up Claude Fable 5 for scraping

4 routes cover most needs, ordered from fastest to most automated. Pick the one that matches how you already work.

Option #1: Claude.ai with no code

The quickest start runs entirely in the Claude.ai chat window, with no setup beyond selecting the model:

Open Claude.ai or your Claude desktop app, choose Fable 5 in the model picker, and describe the scrape in plain language. Every Claude.ai chat has had a full container environment since September 2025 that runs code, installs packages, and clones GitHub repositories, so you can ask Fable 5 to write a scraper, run it in that sandbox, and hand back a clean file in the same conversation. This route fits one-off scrapes, selector prototyping, and anyone who would rather not touch a terminal.

Option #2: The API for repeatable scraping

For jobs you run on a schedule, the API gives you the same model as a programmable endpoint.

Create a key in the Claude Platform console, install the SDK, and call the model string claude-fable-5. A minimal Python extraction looks like this.

import anthropic
 
client = anthropic.Anthropic()   # reads ANTHROPIC_API_KEY
 
html = open("page.html").read()
 
message = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": f"Extract every product as JSON with title, price, rating, url.\n\n{html}",
    }],
)
 
print(message.content[0].text)

import anthropic
 
client = anthropic.Anthropic()   # reads ANTHROPIC_API_KEY
 
html = open("page.html").read()
 
message = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": f"Extract every product as JSON with title, price, rating, url.\n\n{html}",
    }],
)
 
print(message.content[0].text)

Set a lower thinking effort for clean, well-structured pages to save money, and raise it for messy or ambiguous markup. The API also offers a fallback option that routes a blocked request to another model automatically, which keeps the pipeline running if a safeguard ever triggers.

Option #3: Claude Code plus Playwright

For JavaScript-heavy sites and recurring browser work, Claude Code can drive a real browser through Playwright.

Install Claude Code, then ask it to set up Playwright, write the automation, run it, and correct itself. You describe the target in plain English, and it produces and executes the code. A couple of habits help here.

• Watch it work. Ask Claude Code to switch Playwright to headless mode while debugging so you can see the browser and catch visual problems fast.
• Scale with parallel agents. Spawn several browser agents or sub-agents to scrape many URLs at once.

Claude Code can also handle logins and session state, filling forms and carrying cookies between steps, so it reaches pages that sit behind a sign-in. Keep those credentials in environment variables rather than in the prompt.

Option #4: MCP web scraper server

For a standing capability rather than one-off scripts, a Model Context Protocol server gives Claude a reusable scraping tool.

MCP lets Claude call external tools through a defined interface, and community web scraper servers already handle static and dynamic scraping, full-site crawling, CSS selector extraction, and batched URLs through plain conversation. A server entry in your client config looks roughly like this.

{
  "mcpServers": {
    "web-scraper": {
      "command": "uv",
      "args": ["run", "--with", "mcp[cli]", "mcp", "run", "scraper.py"]
    }
  }
}

{
  "mcpServers": {
    "web-scraper": {
      "command": "uv",
      "args": ["run", "--with", "mcp[cli]", "mcp", "run", "scraper.py"]
    }
  }
}

Once connected, you ask Claude to scrape or crawl in chat, and the server does the fetching. This route fits teams that want scraping available on tap across many projects.

If you would rather not run and maintain the scraping layer yourself, a hosted server like the Decodo MCP Server connects Claude to a managed Web Scraping API. It returns structured output as JSON, Markdown, or screenshots, and handles server-side JavaScript rendering and anti-bot work, so your agent reaches pages that block a plain fetch. Setup takes a few steps.

1. Create a free Decodo account.
2. Activate your free starter plan of Web Scraping API with up to 2K requests or grab a subscription that best matches your data collection needs.
3. Copy the Web Scraping API basic authentication token from the dashboard.
4. Install Node.js 18 or later if you plan to run the server locally.
5. In Claude Desktop, open Settings, then Developer, then Edit Config, and add the hosted server entry below.

{
  "mcpServers": {
    "Decodo": {
      "url": "https://mcp.decodo.com/mcp",
      "headers": {
        "Authorization": "Basic <basic_auth_token>"
      }
    }
  }
}

{
  "mcpServers": {
    "Decodo": {
      "url": "https://mcp.decodo.com/mcp",
      "headers": {
        "Authorization": "Basic <basic_auth_token>"
      }
    }
  }
}

Swap in your own token, fully quit and reopen Claude Desktop so it reloads the config, then ask it to scrape a page or run a search to confirm the tools are live. The same entry works in Claude Code, Cursor, and other MCP clients.

A worked example, scraping a product catalog

A short walkthrough on a public sandbox shows the full loop. A demo catalog, such as a books-to-scrape style site, keeps the example reproducible and safe to copy, so you can practice the workflow before pointing it at real targets.

1. Recon. Ask Fable 5 to inspect the site and report the listing structure, the fields per item, and the pagination pattern, without scraping yet.
2. Write. Have it generate the scraper, Playwright for rendered pages or requests, and a parser for static HTML.
3. Run and self-correct. Let it execute, read any errors, and fix selectors or pagination until the run completes.
4. Structure. Ask for output as JSON or CSV matching a fixed schema of title, price, rating, and url.
5. Validate. Spot-check a sample of rows and ask Fable 5 to flag anomalies or missing fields.

3 prompts cover that loop. Adapt the bracketed parts to your target.

• Recon. "Inspect [URL]. Map the listing structure, the fields on each item, and how pagination works. Report the plan, don’t scrape yet."
• Extract. "Write a Python scraper for [URL] that returns JSON matching {title, price, rating, url}. Handle pagination and add a one-second delay between requests."
• Repair. "This scraper returned empty results on page 3. Here’s the error and the page HTML. Find the cause and patch the selector."

The payoff is a tidy, structured file you can load into a spreadsheet or database, produced in one conversation. Save the working script and rerun it on a schedule, calling Fable 5 again only when the site changes and the scraper breaks.

After the data is collected, you can ask Claude to analyze it, organize it, or create some graphics that you can then share with the team.

Prompting patterns that save tokens and time

A few habits keep costs down and output consistent across pages, which is where most of the savings come from on a long-running job.

• Define the output schema first. Tell Fable 5 the exact JSON shape so extraction stays consistent across pages.
• Give it the content, not just a link. Paste HTML or attach a screenshot when accuracy matters, since the model performs better when it can see the page.
• Push pagination and delays into the code. Ask for a script that pages through results politely rather than one giant pass.
• Match effort to difficulty. Use low effort for clean, repetitive extraction and high effort for tricky pages.
• Ask for checks. Have it write sanity tests on the extracted data and report rows that look wrong.
• Request reusable scripts. For recurring jobs, ask for a parameterized scraper you can rerun without prompting again.

Costs, limits, and when to skip Fable 5

Fable 5 is powerful and priced to match, so the smart play is choosing where it earns its cost.

Pricing runs $10 per 1M input tokens and $50 per 1M output tokens, the same for Fable 5 and Mythos 5, with no surcharge for the long context window.

The model is token-intensive in normal use. Reviewers have spent more than $110 of tokens in a single day of heavy testing and called it token-intensive by design in early-access reviews.

At $50 per 1M output tokens, running Fable 5 as the engine for high-volume, repetitive scraping gets expensive. As a rough sense of scale, a single page of extracted records might cost a fraction of a cent in output, which feels trivial until you multiply it across tens of thousands of pages run daily. A hybrid approach keeps the bill sane.

• Use Fable 5 to design, write, and debug the scraper, and to handle vision-based or unusually messy extraction.
• Run the finished, deterministic script on plain infrastructure, or pass high-volume runtime extraction to a cheaper model such as Claude Haiku or Sonnet.
• Reserve the higher thinking effort levels for pages that actually need reasoning.

Fable 5 also runs safety classifiers covering cybersecurity, biology, and chemistry, and model distillation. A flagged request is handled by Claude Opus 4.8 instead, and Anthropic reports this affects fewer than 5% of sessions, with more than 95% seeing no fallback at all. Ordinary scraping rarely trips these, and the API fallback option keeps a run moving if one does fire.

Respect each site's rate limits and robots.txt, and build polite delays into your scraper. That keeps the job stable and avoids getting blocked partway through a run.

Bottom Line

Fable 5 is the strongest model available for the thinking parts of scraping, writing scrapers, repairing broken ones, and structuring rough output, with long context and top-ranked vision as standout advantages on hard targets. Price keeps it from being the default engine for high-volume runs, so the winning setup uses Fable 5 to build and fix the pipeline and a cheaper path to run it at scale.

Users can try Fable 5 free during the included window on paid plans, which runs through June 22, 2026, then move to the API or a hybrid setup once the scraper works.

Start with one target, one schema, and the recon prompt above.